class ClsFrmKeyValue(Frame):
"""
Класс обеспечивает работу с парой ключ:значение.
"""
def __init__(self, root=None, key='Key', value='None'):
"""
Конструтирует пару ключ:значение.
:param root:
:param key:
:param value:
:return:
"""
self.__root = root
Frame.__init__(self, master=root, border=2, relief='ridge')
self.pack(fill='x', side='top')
self.lbl_key = Label(self, text=key, border=1, relief='ridge', width=14)
self.lbl_key.pack(side='left', fill='x', expand=1)
self.ent_val = Entry(self, border=1, relief='groove')
self.ent_val.pack(side='left', fill='x', expand=1)
self.ent_val.delete(0, 'end')
self.ent_val.insert(0, value)
def get_val(self):
"""
Возвращает значение ключа из пары ключ:значение.
:return:
"""
return self.ent_val.get()
class searchDialog(Toplevel):
def __init__(self, parent, title):
self.top = Toplevel(parent)
self.top.wm_title(title)
self.top.wm_minsize(width=300, height=400)
self.top.bind("<Return>", self.searchThreader)
self.top.bind("<Escape>", self.close)
self.searchy = Text(self.top)
self.searchy.config(wrap=WORD)
self.search_entry = Entry(self.top)
self.close = Button(self.top, text="Close", command=self.close)
self.search_button = Button(self.top,
text="Search",
command=self.searchThreader)
self.scrollbar = Scrollbar(self.top)
self.scrollbar.pack(side=RIGHT, fill=Y, expand=0)
self.searchy.config(yscrollcommand=self.scrollbar.set,
state=DISABLED)
self.searchy.pack(side=TOP, fill=BOTH, expand=1)
self.search_entry.pack(side=LEFT, fill=X, expand=1)
self.close.pack(side=RIGHT, fill=BOTH, expand=0)
self.search_button.pack(side=RIGHT, fill=BOTH, expand=0)
self.linker = HyperlinkManager(self.searchy)
def close(self, event=None):
global SEARCH
SEARCH = None
self.top.destroy()
def putText(self, text):
updateDisplay(text, self.searchy, self.linker)
def clearSearch(self):
self.searchy.config(state=NORMAL)
self.searchy.delete(1.0, END)
self.searchy.config(state=DISABLED)
def searchThreader(self, event=None, text=None):
self.sear = upThread(6, 'search', (self, text))
self.sear.start()
def search(self, toSearch=None):
if toSearch is None:
keyword = self.search_entry.get()
self.search_entry.delete(0, END)
else:
keyword = toSearch
self.clearSearch()
self.top.wm_title("Search - " + keyword)
if keyword.split('@')[0] == '':
self.putText(
API.GetUserTimeline(
screen_name=keyword.split('@')[1]
)
)
else:
self.putText(API.GetSearch(term=keyword))
class FInput:
""" Class created to manipulate files for output """
def __init__(self, master, label=""):
self.label = Label(master, text=label)
self.entry = Entry(master)
self.button = Button(master, text="Open", command=self.getLoadName)
self.options = {}
def __call__(self):
return self.entry.get()
def set(self, value):
self.entry.delete(0, END)
self.entry.insert(0, value)
def setOptions(self, options):
""" Getting the options """
self.options = options
def getLoadName(self):
""" The method that takes the filename """
filename = tkFileDialog.askopenfilename(**self.options)
self.entry.delete(0, END)
self.entry.insert(0, filename)
def enable(self):
self.label.config(state=NORMAL)
self.entry.config(state=NORMAL)
self.button.config(state=NORMAL)
def disable(self):
self.label.config(state=DISABLED)
self.entry.config(state=DISABLED)
self.button.config(state=DISABLED)
class ReadOnlyEntry(Frame):
def __init__(self, master, withFocus = True):
'''
withFocus -> enabled
User can set the widget to focus, but the widget will not update
while it has user focus (even programatically it cannot be updated)
withFocus -> disabled
User cannot set focus on the Entry widget. The moment it gets focus,
focus is shifted to a dummy Frame.
Widget can be updated programatically anytime.
Note: in both cases the widget is readonly
'''
Frame.__init__(self, master)
self.master = master
self.withFocus = withFocus
self.hasFocus = False
vcmd = (self.master.register(self.onValidate),
'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
self.readOnlyEntry = Entry(self, justify=CENTER, validate="all", validatecommand=vcmd, width=50)
self.readOnlyEntry.grid(row=0, column=0)
self.dummyFrame = Frame(self)
self.dummyFrame.grid(row=0, column=1)
def onValidate(self, d, i, P, s, S, v, V, W):
"""
If withFocus is True, then do not accept keyboard inputs
If withFocus is False, set focus to the dummy Frame that is not visible
"""
if self.withFocus == True:
if V == "focusin":
self.hasFocus = True
elif V == "focusout":
self.hasFocus = False
if self.hasFocus == False and V == "key":
return True
else:
return False
else:
if V == "focusin":
self.dummyFrame.focus_set()
return True
def configure(self, **kwargs):
self.readOnlyEntry.configure(**kwargs)
def config(self, **kwargs):
self.configure(**kwargs)
def get(self):
return self.readOnlyEntry.get()
def set(self, text):
self.readOnlyEntry.delete(0, END)
self.readOnlyEntry.insert(0, text)
class UsernameOverlay(Overlay):
def __init__(self, *args, **kwargs):
Overlay.__init__(self, *args, **kwargs)
self.label = ""
self.field = ""
self.button = ""
self.user = ""
self.logger = JPYLogger(self)
self.config(
background="gold",
cursor="arrow"
)
self.renderLabel()
self.renderField()
self.renderButton()
def renderLabel(self):
self.label = Label(self)
self.label.config(
text="CHANGE PLAYERNAME",
font=Fonts.MONEY_BIG,
background="gold"
)
self.label.pack()
def renderField(self):
self.field = Entry(self)
self.field.config(
relief="solid",
bd=2,
highlightcolor="black",
font=Fonts.USER_LABEL_NAME_BIG
)
self.field.pack()
def renderButton(self):
Label(self, text='\n', background="gold").pack()
self.button = Button(self)
self.button.config(
text="OK",
relief="solid",
background="black",
foreground="gold",
font=Fonts.MONEY_MEDIUM,
command=self.save
)
self.button.pack()
def save(self):
self.logger.prompt("User " + str(self.user.id) + " changed name from '" + self.user.name.get() + "' to '" + self.field.get() + "'")
self.user.name.set(self.field.get())
self.hide(self)
self.root.root.inputController.blockBuzzer = False
def insert(self, user):
self.field.delete(0, END)
self.field.insert(0, user.name.get())
class GUI(object):
def __init__(self, master):
self.master = master
master.title("Calculator")
self.calculator = Calculator()
self.entered_number = 0
self.total_label_text = IntVar()
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Total:")
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.add_button = Button(master, text="+", command=lambda: self.update("add"))
self.subtract_button = Button(master, text="-", command=lambda: self.update("subtract"))
self.reset_button = Button(master, text="Reset", command=lambda: self.update("reset"))
# LAYOUT
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=2, sticky=E)
self.entry.grid(row=1, column=0, columnspan=3, sticky=W+E)
self.add_button.grid(row=2, column=0)
self.subtract_button.grid(row=2, column=1)
self.reset_button.grid(row=2, column=2, sticky=W+E)
self.update_total()
def update_total(self):
self.total_label_text.set(self.calculator.total)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.entered_number = 0
return True
try:
self.entered_number = int(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "add":
self.calculator.add(self.entered_number)
elif method == "subtract":
self.calculator.sub(self.entered_number)
else: # reset
self.calculator.reset()
self.update_total()
self.entry.delete(0, END)
class Calculator:
def __init__(self, master):
self.master = master
master.title("Simple Calculator")
self.total = 0
self.entered_number = 0
self.total_label_text = IntVar()
self.total_label_text.set(self.total)
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Result:")
vcmd = master.register(self.validate)
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.add_button = Button(master, text="+", command=lambda: self.update("add"))
self.subtract_button = Button(master, text="-", command=lambda: self.update("subtract"))
self.divide_button = Button(master, text="/", command=lambda: self.update("divide"))
self.multipy_button = Button(master, text="*", command=lambda: self.update("multiply"))
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=4, sticky=E)
self.entry.grid(row=1, column=0, columnspan=3, sticky=W+E)
self.add_button.grid(row=2, column=0)
self.subtract_button.grid(row=2, column=1)
self.multiply_button.grid(row=2, column=2)
self.divide_button.grid(row=2, column=3)
def validate(self, new_text):
if not new_text:
self.entered_number = 0
return True
try:
self.entered_number = int(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "add":
self.total += self.entered_number
elif method == "subtract":
self.total -= self.entered_number
else: # reset
self.total = 0
self.total_label_text.set(self.total)
self.entry.delete(0, END)
class SendGCode(LabelFrame):
def __init__(self, root, prtr, settings, log, *arg):
LabelFrame.__init__(self, root, *arg, text="Send gcode")
self.app = root
self.printer = prtr
self.settings = settings
self.log = log
self.entry = Entry(self, width=50)
self.entry.grid(row=1, column=1, columnspan=3, sticky=N+E+W)
self.bSend = Button(self, text="Send", width=4, command=self.doSend, state=DISABLED)
self.bSend.grid(row=1, column=4, padx=2)
self.entry.delete(0, END)
self.entry.bind('<Return>', self.hitEnter)
self.gcv = StringVar(self)
gclist = gcoderef.gcKeys()
self.gcv.set(gclist[0])
l = Label(self, text="G Code Reference:", justify=LEFT)
l.grid(row=2, column=1, columnspan=2, sticky=W)
self.gcm = Combobox(self, textvariable=self.gcv)
self.gcm['values'] = gclist
self.gcm.grid(row=2, column=3, padx=2)
self.gcm.bind('<<ComboboxSelected>>', self.gcodeSel)
#self.bInfo = Button(self, text="Info", width=9, command=self.doInfo)
#self.bInfo.grid(row=2, column=4, padx=2)
#def doInfo(self):
def gcodeSel(self, *arg):
verb = self.gcv.get()
self.log.logMsg("%s: %s" % (verb, gcoderef.gcText(verb)))
def activate(self, flag):
if flag:
self.bSend.config(state=NORMAL)
else:
self.bSend.config(state=DISABLED)
def hitEnter(self, e):
self.doSend()
def doSend(self):
cmd = self.entry.get()
verb = cmd.split()[0]
if self.app.printerAvailable(cmd=verb):
self.log.logMsg("Sending: %s" % cmd)
self.printer.send_now(cmd)
class TkList(List):
def __init__(self, file, tk):
List.__init__(self, file)
# Create the frame with list items
self.frame = Frame(tk, padx = 0, pady = 10, bd = 0)
self.frame.pack()
# Create the field to input new list items
self.input = Entry(tk, width = 32, bd = 1, insertborderwidth = 1, relief = FLAT)
self.input.pack(anchor = N, pady = 4, side = LEFT, fill = X)
self.input.focus_set()
self.input.bind('<Return>', lambda l: self.add_item(self.input.get()))
# Create an add button to the input field
Button(tk, text = "+", relief = FLAT, command = lambda: self.add_item(self.input.get())).pack(anchor = N, side = RIGHT)
# Update the list frame
self.update()
def add_item(self, text):
List.add_item(self, text)
# Clear input field
self.input.delete(0, END)
# Update the list frame
self.update()
def remove_item(self, text):
List.remove_item(self, text)
# Update the list frame
self.update()
def checkbox(self, text):
# Return a button that will remove the list item
return Button(self.frame, text = "-", relief = FLAT, command = lambda: self.remove_item(text))
def update(self):
# Remove previous list items
for child in self.frame.winfo_children():
child.destroy()
# Draw each item in the list
i = 0
for item in self.list:
self.checkbox(item).grid(row = i)
Label(self.frame, text = item).grid(row = i, column = 1)
i = i + 1
# Save the list
List.save_list(self)
class Scroller(object):
"""
Scrolls through a solution list.
"""
def __init__(self, wdw, sols):
"""
Stores the list of solutions in sols
and defines the layout of the GUI.
"""
wdw.title('solutions scroller')
self.sols = sols
self.cursor = 0
self.lbl = Label(wdw, text="solution : ")
self.lbl.grid(row=0, column=0, sticky=E)
self.ent = Entry(wdw)
self.ent.grid(row=0, column=1, stick=W)
self.ent.insert(INSERT, "0 of %d" % len(sols))
self.myft = Font(family="Courier New", size=12, weight="normal")
self.mlen = self.myft.measure("M")
lines = sols[0].split('\n')
self.width = max([len(line) for line in lines])
self.display = StringVar()
self.display.set(self.sols[0])
self.mess = Message(wdw, textvariable=self.display, \
font=self.myft, width=self.width*self.mlen, background='white')
self.mess.grid(row=1, column=0, columnspan=2)
self.btnext = Button(wdw, command=self.next, text='next')
self.btnext.grid(row=2, column=1, sticky=W+E)
self.btprev = Button(wdw, command=self.previous, text='previous')
self.btprev.grid(row=2, column=0, sticky=W+E)
def show(self):
"""
Shows the solution at position self.cursor
in the message widget and updates the entry widget.
"""
self.display.set(self.sols[self.cursor])
self.ent.delete(0, END)
self.ent.insert(INSERT, '%d of %d' % (self.cursor, len(self.sols)))
def next(self):
"""
Increases the cursor by one if possible.
"""
if self.cursor < len(self.sols) - 1:
self.cursor = self.cursor + 1
self.show()
def previous(self):
"""
Decreases the cursor by one if possible.
"""
if self.cursor > 0:
self.cursor = self.cursor - 1
self.show()
class Scroller(object):
"""
Scrolls through a solution list.
"""
def __init__(self, wdw, sols):
"""
Stores the list of solutions in sols
and defines the layout of the GUI.
"""
wdw.title('solutions scroller')
self.sols = sols
self.cursor = 0
self.lbl = Label(wdw, text="solution : ")
self.lbl.grid(row=0, column=0, sticky=E)
self.ent = Entry(wdw)
self.ent.grid(row=0, column=1, stick=W)
self.ent.insert(INSERT, "0 of %d" % len(sols))
self.myft = Font(family="Courier New", size=12, weight="normal")
self.mlen = self.myft.measure("M")
lines = sols[0].split('\n')
self.width = max([len(line) for line in lines])
self.display = StringVar()
self.display.set(self.sols[0])
self.mess = Message(wdw, textvariable=self.display, \
font=self.myft, width=self.width*self.mlen, background='white')
self.mess.grid(row=1, column=0, columnspan=2)
self.btnext = Button(wdw, command=self.next, text='next')
self.btnext.grid(row=2, column=1, sticky=W + E)
self.btprev = Button(wdw, command=self.previous, text='previous')
self.btprev.grid(row=2, column=0, sticky=W + E)
def show(self):
"""
Shows the solution at position self.cursor
in the message widget and updates the entry widget.
"""
self.display.set(self.sols[self.cursor])
self.ent.delete(0, END)
self.ent.insert(INSERT, '%d of %d' % (self.cursor, len(self.sols)))
def next(self):
"""
Increases the cursor by one if possible.
"""
if self.cursor < len(self.sols) - 1:
self.cursor = self.cursor + 1
self.show()
def previous(self):
"""
Decreases the cursor by one if possible.
"""
if self.cursor > 0:
self.cursor = self.cursor - 1
self.show()
class Calculator:
def __init__(self, master):
self.master = master
master.title("Calculator")
self.total = 0
self.entered_number = 0
self.total_label_text = IntVar()
self.total_label_text.set(self.total)
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Total:")
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.add_button = Button(master, text="+", command=lambda: self.update("add"))
self.subtract_button = Button(master, text="-", command=lambda: self.update("subtract"))
self.reset_button = Button(master, text="Reset", command=lambda: self.update("reset"))
# LAYOUT
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=2, sticky=E)
self.entry.grid(row=1, column=0, columnspan=3, sticky=W+E)
self.add_button.grid(row=2, column=0)
self.subtract_button.grid(row=2, column=1)
self.reset_button.grid(row=2, column=2, sticky=W+E)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.entered_number = 0
return True
try:
self.entered_number = int(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "add":
self.total += self.entered_number
elif method == "subtract":
self.total -= self.entered_number
else: # reset
self.total = 0
self.total_label_text.set(self.total)
self.entry.delete(0, END)
def makeCmdButton(self, parent, cmd, row):
cmdText = Entry(parent, width=self.cmdWidth)
cmdText.grid(row=row, column=1, sticky="ew", ipady=2)
cmdText.delete(0, END)
cmdText.insert(0, cmd["cmd"])
button = Button(parent, text=cmd["button"], command=lambda: self.execute(cmd["button"], cmdText))
button.grid(row=row, column=0, sticky="ew", padx=2, pady=2)
if "tooltip" in cmd:
ToolTip(button, cmd["tooltip"])
ToolTip(cmdText, cmd["tooltip"])
class tester(tk.Frame):
def __init__(self, parent):
self.parent = parent
self.frame = tk.Frame(self.parent)
self.canvas = tk.Canvas(parent, width=100, height=100)
self.canvas.pack()
self.key_dict = {}
self.game_over = False
#keep track of keypress
self.c = 0
self.input_box(parent)
B = tk.Button(parent, text="playback states", command=self.start)
B.pack()
def start(self):
try:
# Bind entry to any keypress
self.entry.bind("<Key>", self.click)
# while self.c<5:
# if time.time()-start >=2:
# print('start thread')
# inp = Process(target = self.input_box)
# inp.start()
# inp.join() #dont make killed process a zombie
# inp.terminate()
# start = time.time()
# self.c+=1
except:
print("Error: unable to start thread")
def input_box(self, parent):
self.entry = Entry()
self.entry.focus_set()
self.entry.pack()
def click(self, key):
# print the key that was pressed
print(key.char)
self.clear_entry()
def clear_entry(self):
self.entry.delete(0, "end")
root.update()
class GuessingGame:
def __init__(self, master):
self.master = master
master.title("Catalyst Engine")
self.guess = None
self.message = "Beta Engine"
self.label_text = StringVar()
self.label_text.set(self.message)
self.label = Label(master, textvariable=self.label_text)
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.guess_button = Button(master, text="Search", command=self.guess_number)
self.close_button = Button(master, text="Close", command=self.callback)
self.label.grid(row=0, column=0, columnspan=2, sticky=W+E)
self.entry.grid(row=1, column=0, columnspan=2, sticky=W+E)
self.guess_button.grid(row=2, column=0)
self.close_button.grid(row=2, column=1)
def validate(self, new_text):
if new_text: # the field is being cleared
self.guess = None
return True
def guess_number(self):
if self.guess is None:
self.message = 'Enter a Term'
else:
self.message = ''
self.label_text.set(self.message)
def close(self):
self.entry.delete(END)
def callback(self):
if tkMessageBox.askokcancel("Quit", "Do you really wish to quit?"):
root.destroy()
class ButtonEntry(Frame):
def __init__(self, parent, width=20):
Frame.__init__(self, parent)
self.browseButton = Button(self, text="Browse", command=self.browse)
self.fileEntry = Entry(self, width=width)
self.browseButton.pack(side=LEFT)
self.fileEntry.pack(side=LEFT)
def browse(self):
filename = tkFileDialog.askopenfilename(filetypes = (("Tldr Files", "*.tldr"),))
if filename:
self.filename = filename
self.fileEntry.delete(0, END)
width = int(self.fileEntry['width'])
if len(filename) > width:
filename = "...%s" % (filename[-width:])
self.fileEntry.insert(0, filename)
def get(self):
return self.filename
class Entrada(Frame):
"""
ui.Entrada
----------
Control para obtener la entrada del usuario.
"""
def __init__(self, padre):
Frame.__init__(self, padre)
self.__prompt = Label(self, text=">>> ")
self.__entrada = Entry(self)
self.__prompt.pack(side=LEFT)
self.__entrada.pack(fill=BOTH)
def leer(self):
"""
ui.Entrada.leer()
-----------------
Lee la entrada ingresada por el usuario en el campo de texto.
DEVUELVE
* Una cadena de caracteres con la entrada leida del usuario.
"""
return self.__entrada.get()
def limpiar(self):
"""
ui.Entrada.limpiar()
--------------------
Elimina el texto actualmente contenido en el campo de texto
DEVUELVE
* Nada
"""
self.__entrada.delete(0, END)
class editPool(Frame):
font_decorations = ('italic', 'bold', 'subscript', 'superscript')
font_decorations_to_names = {
'italic': _('italic'),
'bold': _('bold'),
'subscript': _('subscript'),
'superscript': _('superscript')
}
font_decorations_to_html = {
'italic': 'i',
'bold': 'b',
'subscript': 'sub',
'superscript': 'sup'
}
def __init__(self, master, buttons=('interpret', 'asis'), **kw):
Frame.__init__(self, master, **kw)
self.text = ''
self.interpret = 1
self.editPool = Entry(self,
width=50,
state='disabled',
font="Helvetica 12")
self.editPool.pack(side='left')
self.editPool.bind('<Return>', self._interpretButtonPressed)
self.editPool.bind('<Escape>', self._cancel)
self.editPool.bind('<Control-s>', lambda e: self._tag_it("sub"))
self.editPool.bind('<Control-S>', lambda e: self._tag_it("sup"))
self.editPool.bind('<Control-i>', lambda e: self._tag_it("i"))
self.editPool.bind('<Control-b>', lambda e: self._tag_it("b"))
self.editPool.bind("<KeyPress>", self._key)
if 'interpret' in buttons:
pix = Store.app.request('pixmap', name='interpret')
self.interpretButton = Button(self,
text=_('Interpret'),
image=pix,
command=self._interpretButtonPressed,
state='disabled',
bd=config.border_width)
Store.app.balloon.bind(self.interpretButton,
_('Interpret text (where applicable)'))
self.interpretButton.pack(side='left')
else:
self.interpretButton = None
if 'asis' in buttons:
pix = Store.app.request('pixmap', name='asis')
self.setButton = Button(self,
image=pix,
text=_('As is'),
command=self._setButtonPressed,
state='disabled',
bd=config.border_width)
Store.app.balloon.bind(self.setButton,
_('Leave text as is - do not interpret'))
self.setButton.pack(side='left')
else:
self.setButton = None
pix = Store.app.request('pixmap', name='subnum')
self.numbersToSubButton = Button(
self,
image=pix,
text=_('Sub numbers'),
command=self._numbersToSubButtonPressed,
state='disabled',
bd=config.border_width)
Store.app.balloon.bind(self.numbersToSubButton,
_('Convert numbers to subscript'))
self.numbersToSubButton.pack(side='left')
# text decoration
decorFrame = Frame(self)
decorFrame.pack(padx=5, side="left")
for i in self.font_decorations:
pix = Store.app.request('pixmap', name=i)
self.__dict__[i] = Button(
self,
image=pix,
command=misc.lazy_apply(self._tag_it,
(self.font_decorations_to_html[i], )),
state='disabled',
text=self.font_decorations_to_names[i],
bd=config.border_width)
Store.app.balloon.bind(self.__dict__[i],
self.font_decorations_to_names[i])
self.__dict__[i].pack(side="left")
# special characters
pix = Store.app.request('pixmap', name='specialchar')
self.specialCharButton = Button(self,
image=pix,
text=_('Special Character'),
command=self._specialCharButtonPressed,
state='disabled',
bd=config.border_width)
Store.app.balloon.bind(self.specialCharButton,
_('Insert a special character'))
self.specialCharButton.pack(side='left')
self.active = False
def _interpretButtonPressed(self, *e):
t = self.editPool.get()
if string.lower(t) in groups_table:
self._setText(t)
#self._setText( groups_table[ string.lower(t)]['text'])
#self.editPool.insert(0, self.text)
else:
self._setText(t)
self.text = re.sub("\\\\n", "\n", self.text)
self._quit()
def _setButtonPressed(self, *e):
self._setText(self.editPool.get())
self.interpret = 0
self._quit()
def _numbersToSubButtonPressed(self, *e):
self._setText(re.sub("\d+", '<sub>\g<0></sub>', self.editPool.get()))
self._quit()
def _cancel(self, e):
self._setText(None)
self.active = False
self._quit()
def _quit(self):
self.grab_release()
self._disable()
self._normaly_terminated = 1
self.active = False
self.quit()
def _disable(self):
self.interpretButton.configure(state='disabled')
self.numbersToSubButton.configure(state='disabled')
self.setButton.configure(state='disabled')
self.editPool.configure(state='disabled')
self.italic.configure(state='disabled')
self.bold.configure(state='disabled')
self.superscript.configure(state='disabled')
self.subscript.configure(state='disabled')
self.specialCharButton.configure(state='disabled')
def _enable(self):
self.interpretButton.configure(state='normal')
self.numbersToSubButton.configure(state='normal')
self.setButton.configure(state='normal')
self.editPool.configure(state='normal')
self.italic.configure(state='normal')
self.bold.configure(state='normal')
self.superscript.configure(state='normal')
self.subscript.configure(state='normal')
self.specialCharButton.configure(state='normal')
def _setText(self, text):
self.text = text
self._update()
def _update(self):
self.editPool.delete(0, last='end')
if self.text:
self.editPool.insert(0, self.text)
def activate(self, text=None, select=1):
"""activates edit_pool and returns inserted value (None if cancel occured),
if parameter text is None it preserves the old one, use text='' to delete old text"""
self.active = True
self.interpret = 1
self.focus_set()
self.grab_set()
self._enable()
# this is because I need to distinguish whether the mainloop was terminated "from inside"
# or from outside (this most of the time means the application was killed and the widgets are no longer available)
self._normaly_terminated = 0
if text != None:
self._setText(text)
self.editPool.focus_set()
if select:
self.editPool.selection_range(0, 'end')
self.mainloop()
if self._normaly_terminated:
return self.text
else:
return None
def _tag_it(self, tag):
if self.editPool.selection_present():
self.editPool.insert(Tkinter.SEL_FIRST, '<%s>' % tag)
self.editPool.insert(Tkinter.SEL_LAST, '</%s>' % tag)
else:
self.editPool.insert(Tkinter.INSERT, '<%s></%s>' % (tag, tag))
self.editPool.icursor(
self.editPool.index(Tkinter.INSERT) - len(tag) - 3)
def _key(self, event):
if len(event.keysym) > 1 and event.keysym in keysyms:
if self.editPool.selection_present():
self.editPool.delete("anchor", "insert")
self.editPool.insert('insert', unicode(keysyms[event.keysym]))
return "break"
def _specialCharButtonPressed(self):
dialog = special_character_menu(self._insertText)
dialog.post(self.specialCharButton.winfo_rootx(),
self.specialCharButton.winfo_rooty())
def _insertText(self, text):
if text != None:
self.editPool.insert(Tkinter.INSERT, text)
self.grab_set()
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.Queue()
self.train_queue = 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'),
'wb') as configfile:
user_config.write(configfile)
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 Queue.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 MyPoti(Tkinter.Tk):
def __init__(self, master):
Tkinter.Tk.__init__(self,master)
self.master = master
self.initialize()
def initialize(self):
#create canvas with specified size and add
w = Canvas(self, width=700, height=600)
w.pack()
#Declare two lists, one for front labels, anthoer for answer labels
self.flabels = []
self.alabels = []
#Define x and y cordinates for lables
self.flblx = 280
self.flbly = 40
self.alblx = 380
self.albly = 40
#Dummy list1
self.my_list = []
#Text to set on front lables
self.str_label = ['POTI0', 'POTI1','POTI2','POTI3','POTI4']
#Trigger to check if we want to program or pause
self.running = True
#Define environment varibales for input text fields
#We can change/update this during runtime
self.entry_pot_var = Tkinter.StringVar()
self.entry_res_var = Tkinter.StringVar()
#Define text areas for input onr for poti selection and one for resistence value
self.entry_pot = Entry(self,textvariable=self.entry_pot_var, validate="focusout")
self.entry_res = Entry(self,textvariable=self.entry_res_var, validate="focusout")
#Initial text to display on above text fields
self.entry_pot_var.set("Enter Pot selection")
self.entry_res_var.set("Enter resistor value - 2000 to 100000")
#Set pot selection entry as highlighted
self.entry_pot.selection_range(0,Tkinter.END)
#self.entry_res.selection_range(0,Tkinter.END)
#Set keyboard focus on pot text field
self.entry_pot.focus_set()
#Add pot text field to canvas
self.entry_pot.pack()
#ToDO
#validate input for pot selection
#self.entry_pot["validatecommand"] = (self.register(self.check_pot), "%P")
#Add resistence text field to canvas
self.entry_res.pack()
#Create two text on the canvas with x and y coodrinates
w.create_window(120, 40, window=self.entry_pot)
w.create_window(120, 70,window=self.entry_res)
#We declare 5 front lables and add them to canvas with x and y co ordinates
for x in range(5):
print self.str_label[x]
self.label = Label(self, text=self.str_label[x], fg='white', bg='black')
self.label.pack()
self.flabels.append(self.label)
#We declare 5 answer lables and add them to canvas with x and y co ordinates
for x in range(5):
self.label = Label(self, text='values', fg='white', bg='blue')
self.label.pack()
self.alabels.append(self.label)
#Create front label in canvas
for label in self.flabels:
w.create_window(self.flblx,self.flbly,window=label)
self.flbly = self.flbly + 19
#Create answer label in cavas
for label in self.alabels:
w.create_window(self.alblx,self.albly,window=label)
self.albly = self.albly + 20
###
#Button definitions
###
#Start button, and add callback to start_app function when this button is clicked
self.start_button = Button(self, text="Set", height=2, width=10, command=self.start_app)
self.start_button.pack()
#Clear button, and add callback to clear_app function when this button is clicked
self.clear_button = Button(self, text="Clear", height=2, width=10, command=self.clear_app, state="disabled")
self.clear_button.pack()
#Clear button, and add quit function of tkinter master when this button is clicked
self.close_button = Button(self, text="Close", height=2, width=10, command=self.quit)
self.close_button.pack()
#Add buttons to canvas
w.create_window(70, 170, window=self.start_button)
w.create_window(190, 170, window=self.close_button)
w.create_window(310, 170, window=self.clear_button)
#Input validation for pot selection text field
def check_pot(self, txt):
print("POT validate!")
#pot = self.entry_pot_var.get()
if int(txt):
if txt < 0 or txt > 4 :
return False
else:
return True
else:
print("Not integer")
self.entry_pot.focus_set()
self.entry_pot.delete(0, END)
return False
#Input validation for resistence text field
def check_res(self):
print("Greetings!")
def start_app(self):
"""
Start the application when start button pressed
"""
#Disable start button after presed
global running
self.running = True
#self.start_button.config(state="disabled")
self.clear_button.config(state="normal")
print "Starting app!"
#call update values function
self.update_values()
def clear_app(self):
"""
Clear the answer lable fields
"""
print "Clear"
global running
self.running = False
self.start_button.config(state="normal")
self.clear_button.config(state="disabled")
for i in range(5):
self.alabels[i].config(text=str("values"))
#Clear the text fields and set default vaule
self.entry_pot_var.set("Enter Pot selection")
self.entry_res_var.set("Enter resistor value - 2000 to 100000")
#set keyboard focus
self.entry_pot.focus_set()
def stop_app(self):
"""
Stop the app
"""
print "Stopping"
self.quit()
def update_values(self):
"""
Helper function to trigger label values after reading pot and res values
"""
#if self.running:
# self.after(1000, self.update_values)
#Read input value given for pot selection text field
pot = self.entry_pot.get()
###if pot < 0 or pot > 4 : ###
if int(pot) < 0 or int(pot) > 4 :
tkMessageBox.showerror("wrong input","wrong input, pot selection must be 0-4, current selection: %s" % pot)
return
res = self.entry_res.get()
#Read input value given for resistence text field
res = self.entry_res.get()
#call update text value function which converts values and send data to MCP
self.update_text_values(pot, res)
def update_text_values(self, pot, res):
"""
Update the answer lables values with resistence
"""
#resisitor to data conversion
byte = 256
local_pot = 100000
local_res = 125
#rw = int(res) * 1000
#rw = int(rw) - int(local_res)
#lev = float((rw * byte) / local_pot)
#level =round(lev)
#level = int(level)
#level = int(res) - int(local_res)
if float(res):
level = float(res) - int(local_res)
else:
level = int(res) - int(local_res)
level = (level * byte) / local_pot
level = int(level)
print(level)
b = 0
if int(pot) == 0:
b = "0001" "0001" "{0:08b}".format(level)
if int(pot) == 1:
b = "0001" "0001" "{0:08b}" '{0:016b}'.format(level)
if int(pot) == 2:
b = "0001" "0001" "{0:08b}" '{0:032b}'.format(level)
if int(pot) == 3:
b = "0001" "0001" "{0:08b}" '{0:048b}'.format(level)
if int(pot) == 4:
b = "0001" "0001" "{0:08b}" '{0:064b}'.format(level)
print b
#update answer label based on poti selection
self.alabels[int(pot)].config(text=str(level))
for x in b:
GPIO.output(SPI_SDI_PIN, int(x))
print(int(x))
GPIO.output(SPI_CLK_PIN, True)
GPIO.output(SPI_CLK_PIN, False)
GPIO.output(SPI_CS_PIN, True)
self.update_idletasks()
class CreateView(Frame):
"""A class describing the list creation page of the UI"""
def __init__(self, parent, height, width, border_style, border_width,
background_colour):
Frame.__init__(self, parent, height=height, width=width)
#Connect to the word/list database
self.db = SpellingDatabase()
self.parent = parent
#Create a frame containing a menu for choosing word category
categorymenu_frame = Frame(self, width=340, height=30, relief=SUNKEN, bd=1)
categorymenu_frame.pack_propagate(0)
categorymenu_label = Label(categorymenu_frame, text="Category:")
wordlist_title = Label(categorymenu_frame, text="Select Words")
#Menu options: one for each category of word
optionList = ("Child", "ESOL", "Spelling Bee", "Custom")
self.category_v = StringVar()
self.category_v.set(optionList[0])
#Command causes word browser to be populated with words from chosen category
self.category_menu = OptionMenu(categorymenu_frame, self.category_v, *optionList, command=self.update_category)
self.category_menu.config(width=10)
self.category_menu.pack(side=RIGHT)
categorymenu_label.pack(side=RIGHT)
wordlist_title.pack(side=LEFT)
#Create frame for the title of the user list panel
userlist_title_frame = Frame(self, width=340, height=30)
userlist_title_frame.pack_propagate(0)
userlist_title = Label(userlist_title_frame, text="Your New List")
userlist_title_frame.grid(column=2, row=0)
userlist_title.pack(side=LEFT)
#Create frame for middle bar containing transfer buttons
middlebar_frame = Frame(self, width = 70, height=400)
middlebar_frame.grid_propagate(0)
#Buttons transfer words from one list to the other
transfer_right_button = Button(middlebar_frame, text="->", command=self.transfer_right)
transfer_left_button = Button(middlebar_frame, text="<-", command=self.transfer_left)
#Press this button to generate a random list from the current category
random_list_button = Button(middlebar_frame, text="Create", command=self.random_list)
random_list_label = Label(middlebar_frame, text="Random\nList")
self.random_list_entry = Entry(middlebar_frame, width=3, justify=RIGHT)
self.random_list_entry.insert(0, 15)
transfer_left_button.grid(column=0, row=1, padx=15, pady=50)
transfer_right_button.grid(column=0, row=0, padx=15, pady=50)
random_list_label.grid(column=0, row=2, pady=3)
self.random_list_entry.grid(column=0, row=3, pady=3)
random_list_button.grid(column=0, row=4, pady=3)
middlebar_frame.grid(column=1, row=1)
#random_list_button.grid(column=0, row=2)
#Create frame for "Add New Word" menu
addword_frame = Frame(self, width=340, height=150, bd=2, relief=SUNKEN)
addword_frame.grid_propagate(0)
addword_label = Label(addword_frame, text = "Add a new word:")
word_label = Label(addword_frame, text="Word:")
def_label = Label(addword_frame, text="Definition:")
use_label = Label(addword_frame, text="Example of Use:")
difficulty_label = Label(addword_frame, text="Difficulty:")
#Entry boxes and an option menu allowing the user to enter attributes of the new word
self.addword_entry = Entry(addword_frame, width = 28)
self.adddefinition_entry = Entry(addword_frame, width=28)
self.adduse_entry = Entry(addword_frame, width=28)
self.difficulty_v = StringVar()
self.difficulty_v.set("1")
difficulty_list = range(1,9)
self.difficulty_menu = OptionMenu(addword_frame, self.difficulty_v, *difficulty_list)
#Pressing this button adds the new word to the database
addword_button = Button(addword_frame, text = "Add", command = self.add_word)
addword_label.grid(row=0, column=0, sticky=W)
addword_button.grid(row=0, column=1, pady=2, sticky=E)
word_label.grid(row=1, column=0, sticky=W)
def_label.grid(row=2, column=0, sticky=W)
use_label.grid(row=3, column=0, sticky=W)
difficulty_label.grid(row=4, column=0, sticky=W)
self.addword_entry.grid(row=1, column=1, pady=2, sticky=E)
self.adddefinition_entry.grid(row=2, column=1, pady=2, sticky=E)
self.adduse_entry.grid(row=3, column=1, pady=2, sticky=E)
self.difficulty_menu.grid(row=4, column=1, pady=2, sticky=E)
addword_frame.grid(column=0, row=2)
#Frame for menu allowing users to save their new lists
savelist_frame = Frame(self, width=340, height=30, bd=2, relief=SUNKEN)
savelist_frame.pack_propagate(0)
savelist_label = Label(savelist_frame, text="List Name:")
#User enters the name of the new list here
self.savelist_entry = Entry(savelist_frame, width=25)
#Pressing this button adds the new list to the database
savelist_button = Button(savelist_frame, text="Save", command = self.save_list)
savelist_label.pack(side=LEFT)
savelist_button.pack(side=RIGHT)
self.savelist_entry.pack(side=RIGHT, padx=5)
savelist_frame.grid(column=2, row=2, sticky=N, pady=5)
#Create list panel for browsing the words stored in database
self.wordbrowse_frame = ListPane(self, height=25)
categorymenu_frame.grid(column=0, row=0)
self.wordbrowse_frame.grid(column=0, row=1, sticky=N)
#Populate the list with words from database
self.update_category()
#Double-clicking a word has same effect as transfer button
self.wordbrowse_frame.doubleClickFunc = self.transfer_right
#Create list panel for holding/displaying the list being built
self.userlist_frame = ListPane(self, height=25)
self.userlist_frame.grid(column=2, row=1, sticky=N)
#Double-clicking a word has same effect as transfer button
self.userlist_frame.doubleClickFunc = self.transfer_left
def transfer_right(self, index=None):
"""Moves a word from word browser to user list"""
if index == None:
index = self.wordbrowse_frame.listbox.curselection()
if self.wordbrowse_frame.get()!=None:
#Add selection to user list
self.userlist_frame.insert(self.wordbrowse_frame.get())
#Remove selection from word browser
word_list = list(self.wordbrowse_frame.getDisplayed())
word_list.remove(self.wordbrowse_frame.get())
self.wordbrowse_frame.display(word_list)
#Ensure current list contents stay visible and select the next word
self.wordbrowse_frame.listbox.see(index)
self.wordbrowse_frame.listbox.selection_set(index)
def transfer_left(self, index=None):
"""Moves a word from user list back to word browser"""
if index == None:
index = self.userlist_frame.listbox.curselection()
if self.userlist_frame.get()!=None:
word_list = list(self.wordbrowse_frame.getDisplayed())
word_list.append(self.userlist_frame.get())
word_list.sort(key=str.lower)
self.wordbrowse_frame.display(word_list)
word_list = list(self.userlist_frame.getDisplayed())
word_list.remove(self.userlist_frame.get())
self.userlist_frame.display(word_list)
self.userlist_frame.listbox.see(index)
self.userlist_frame.listbox.select_set(index)
def random_list(self):
source_list = self.wordbrowse_frame.getDisplayed()
list_size = int(self.random_list_entry.get())
if list_size > len(source_list):
list_size = len(source_list)
self.random_list_entry.delete(0, END)
self.random_list_entry.insert(0, list_size)
generated_list = random.sample(source_list, list_size)
self.userlist_frame.display(generated_list)
def update_category(self, event=None):
"""Populates the word browser with words from the selected category"""
category = self.category_v.get()
if category == "Child":
category = "CL"
elif category == "ESOL":
category = "AL"
elif category == "Spelling Bee":
category = "SB"
else: category = "UL"
word_records = self.db.sql("SELECT word FROM words WHERE difficulty LIKE '%s%s'"%(category, "%"))
word_list = []
for word in word_records:
word_list.append(str(word[0]))
word_list.sort(key=str.lower)
self.wordbrowse_frame.display(word_list)
def add_word(self):
"""Adds a new word to the database with the attributes entered by the user"""
if self.addword_entry.get() == "":
return
self.db.sql("INSERT INTO words (word, definition, usage, difficulty) VALUES ('%s', '%s', '%s', 'UL%s')"%(self.addword_entry.get(), self.adddefinition_entry.get(), self.adduse_entry.get(), self.difficulty_v.get()))
self.addword_entry.delete(0, END)
self.adddefinition_entry.delete(0, END)
self.adduse_entry.delete(0, END)
#User words are added to a 'Custom' category
self.category_v.set("Custom")
self.update_category(None)
self.db.commit()
def save_list(self):
"""Adds the list contained in the user list panel to the database"""
word_list = self.userlist_frame.getDisplayed()
self.db.createList(word_list, self.savelist_entry.get())
self.savelist_entry.delete(0, END)
self.db.commit()
self.parent.parent.update_lists()
class Main(Frame):
"""
Main class of the system.
"""
def __init__(self, master=None):
"""
Main contstructor. Creates an instance of :class:`Storage<storage.Storage>` and starts the graphics-window.
"""
args = {
"fields": ["name", "date", "lifetime"],
"ident": "name",
"uniqueident": True,
"objectname": "person",
"gui": self,
}
self.storage = Storage(**args)
self.is_clicked = False
self.clicked_id = -1
Frame.__init__(self, master)
self.master.title("Medlemsregister Cybernetisk Selskab")
self.grid(padx=15, pady=15)
if not self.storage._testfile():
path = os.path.abspath(__file__).rsplit("/", 1)[0]
self._popup(
"ERROR!",
'Cannot write to file! make sure folder "{}/medlemslister" exists, then restart..'.format(path),
"error",
)
self.destroy()
self.master.destroy()
return
self.create_elements()
loadmsg = self.storage.load()
if "error" in loadmsg:
self.infotext.set("ERROR! {}".format(loadmsg["error"]))
elif "success" in loadmsg:
self.infotext.set("Success! {}".format(loadmsg["success"]))
self._populate_list()
def create_elements(self):
"""
creates all graphics elements and places them in the graphics grid.
"""
# global shortcuts
self.master.bind("<F1>", self.display_help)
self.master.bind("<Control-f>", self.search)
self.master.bind("<Control-d>", self.delete)
self.master.bind("<Control-r>", self._populate_list)
self.master.bind("<Control-s>", self.save_to_file)
monospace = tkFont.Font(family="Courier", size=10, weight="normal")
# menubar:
menubar = Menu(self.master)
backupmenu = Menu(menubar, tearoff=0)
backupmenu.add_command(label="Backup to Google (Note: Slow!)", command=self.google_write)
backupmenu.add_command(label="Read backup from Google", command=self.google_read)
backupmenu.add_separator()
backupmenu.add_command(label="Merge with Wiki", command=self.wiki_merge)
backupmenu.add_command(label="Overwrite Wiki with local storage", command=self.wiki_overwrite)
specialmenu = Menu(menubar, tearoff=0)
specialmenu.add_command(label="Set as lifetime member", command=self.set_lifetime)
specialmenu.add_command(label="Remove lifetime membership", command=self.unset_lifetime)
specialmenu.add_command(label="Change a users id", command=self.update_id)
menubar.add_cascade(label="Backup", menu=backupmenu)
menubar.add_cascade(label="Special Actions", menu=specialmenu)
menubar.add_command(label="Help (F1)", command=self.display_help)
self.master.config(menu=menubar)
# Info-label
self.infotext = StringVar()
self.info = Label(self, textvariable=self.infotext)
self.info.pack()
self.info.grid(row=0, column=0, columnspan=10)
self.infotext.set("Welcome")
# Save-button
self.savebtn = Button(self, text="Save (enter)", command=self.create, width=11)
self.savebtn.grid(row=3, column=7)
# Omnibar (entry-field for add/search/delete)
self.omnibar = Entry(self, width=28)
self.omnibar.grid(row=3, column=0, columnspan=1)
self.omnibar.bind("<Return>", self.create)
self.omnibar.configure(font=monospace)
# List of members
self.memlist = SL(self, height=25, width=71, callback=self._click_list)
self.memlist.grid(row=7, column=0, columnspan=10)
self.memlist.listbox.configure(font=monospace)
# Search-button
self.searchbtn = Button(self, text="Search (ctrl-f)", command=self.search, width=11)
self.searchbtn.grid(row=3, column=8)
self.searchlist = False
# Delete-button
self.delete_btn = Button(self, text="Delete (ctrl-d)", command=self.delete, width=11)
self.delete_btn.grid(row=3, column=9)
# Counter
self.count = StringVar()
self.countlbl = Label(self, textvariable=self.count)
self.countlbl.pack()
self.countlbl.grid(row=8, column=0, sticky="W")
# Reset list-button
self.refreshbtn = Button(self, text="Refresh list (ctrl-r)", command=self._populate_list, width=12)
self.refreshbtn.grid(row=8, column=9)
# Save to file-button
self.saveallbtn = Button(self, text="Save to file (ctrl-s)", command=self.save_to_file, width=12)
self.saveallbtn.grid(row=8, column=8)
# Help-button
# self.helpbutton=Button(self, text='Help', command=self.display_help, width=11)
# self.helpbutton.grid(row=8, column=7)
def display_help(self, event=None):
"""
Display a new window with help-text from file 'help.txt'
"""
help = Toplevel()
help.title("Help and usage")
path = os.path.abspath(__file__).rsplit("/", 1)[0]
f = open(u"{}/help.txt".format(path), "r")
helptext = f.read()
f.close
helplabel = Label(help, text=helptext, relief=RIDGE, padx=15, pady=15, anchor="w", justify=LEFT, bg="white")
helplabel.pack(side=TOP, fill=BOTH, expand=YES)
def create(self, event=None):
"""
Called when a user clicks the 'save person'-button or presses enter while typing in the name-field.
Sets the info-label with feedback from :class:`Storage<storage.Storage>`
:param event: the button-event of the enter-key.
"""
if self.searchlist:
self._populate_list()
self.searchlist = False
name = self._get_val()
date = dt.now().strftime("%Y-%m-%d %H:%M")
obj = self.storage.create(**{"name": name, "date": date, "lifetime": "n"})
if not "success" in obj:
self.infotext.set(u"FAILURE! {}".format(obj["error"]))
else:
self.infotext.set(u"Success! User added with id: {}".format(obj["success"]))
self._list_add(obj["success"], obj["object"]["name"], obj["object"]["date"])
self._update_count()
def search(self, event=None):
"""
Locate all people matching search-parameters in search-fields.
called when user clicks search or when user presses enter while cursor is in one of the search-fields.
:param event: button-event for enter-click.
"""
self.infotext.set("")
text = self._get_val()
name = ""
date = ""
if len(text.split("-")) > 1 or len(text.split(":")) == 2:
date = text
else:
name = text
args = {"name": name, "date": date}
obj = self.storage.search(**args)
self.searchlist = True
self.memlist.clear()
i = 0
l = 0
for k, v in obj.iteritems():
self._list_add(k, v["name"], v["date"])
if not "L" in "{}".format(k):
i += 1
else:
l += 1
self._update_count(u"Life: {} Normal: {}".format(l, i))
def delete(self, event=None):
"""
Delete a person from collection based on `id`.
called when user clicks delete or when user presses enter while cursor is in the delete-field.
"""
val = self._get_val()
if val == "":
if self.is_clicked:
id = self.clicked_id
self.is_clicked = False
self.clicked_id = -1
else:
self.infotext.set(u"FAILURE! No id provided. Either click a person in the list or write an id.")
return
elif "L" in val:
id = val
else:
id = int(val)
obj = self.storage.read(**{"id": id})
if "success" in obj:
check = self._popup(
u"Really delete?",
u"Do you really want to delete '{}'?".format(obj["success"]["name"].title()),
"warning",
)
if not check:
self.infotext.set(u"Delete aborted..")
return
obj = self.storage.delete(**{"id": id})
if "success" in obj:
self.infotext.set(u"Success! {}".format(obj["success"]))
self._populate_list()
else:
self.infotext.set(u"FAILURE! {}".format(obj["error"]))
self._update_count()
def _list_add(self, id, name, date):
"""
adds a person with id, name and timestamp to the list of users in the ui.
:param id: id of a person.
:param name: name of a person.
:param date: date of a person.
"""
self.memlist.append(u" {:<5} - {:40} - {}".format(id, name.title(), date))
def _populate_list(self, event=None):
"""
Refreshes the list of users in the ui.
"""
self.memlist.clear()
sorted_keys = sorted(self.storage.storage.iterkeys())
for k in sorted_keys:
v = self.storage.storage[k]
self._list_add(k, v["name"], v["date"])
self._update_count()
def _update_count(self, count=None):
"""
Updates the counter in the ui with number from :func:`storage.size()<storage.Storage.size>`
"""
if count:
self.count.set(u"{}".format(count))
else:
self.count.set(u"Total: {}".format(self.storage.size()))
def _click_list(self, linenum):
"""
called when a user clicks a member in the list of members. Saves the id of the user.
:param linenum: the linenumber the user clicked.
"""
line = ""
try:
line = self.memlist[linenum]
except (IndexError):
return
self._get_val()
vals = line.split("-")
if not "L" in vals[0]:
self.clicked_id = int(vals[0].strip())
else:
self.clicked_id = vals[0].strip()
self.is_clicked = True
def google_write(self):
"""
backup collection to a google spreadsheet
"""
obj = self.storage.google_write()
if "success" in obj:
self.infotext.set(u"Success! collection backed up to google spreadsheet.")
else:
self.infotext.set(u"Failure! {}".format(obj["error"]))
def google_read(self):
"""
read backup of collection from a google spreadsheet
"""
obj = self.storage.google_read()
if "success" in obj:
self.infotext.set(u"Success! {}".format(obj["success"]))
self._populate_list()
else:
self.infotext.set(u"Failure! {}".format(obj["error"]))
def wiki_merge(self):
"""
Merge local collection with wiki
"""
self.infotext.set(u"Please Wait...")
val = self.storage.wiki_merge()
val = self.storage.wiki_merge(lifetime=True)
self.infotext.set(val["status"])
def wiki_overwrite(self):
"""
overwrite wiki with data from local storage
"""
self.infotext.set(u"Please Wait...")
val = self.storage.wiki_merge(overwrite_wiki=True, push_to_wiki=True)
val = self.storage.wiki_merge(overwrite_wiki=True, push_to_wiki=True, lifetime=True)
self.infotext.set(val["status"])
def set_lifetime(self):
"""
register lifetime membership for a user. The user is selected by clicking in the list.
"""
if not self.is_clicked:
self.infotext.set(u"FAILURE! No id provided. You have to click a person in the list!.")
return
id = self.clicked_id
self.is_clicked = False
self.clicked_id = -1
obj = self.storage.read(**{"id": id})
if "success" in obj:
check = self._popup(
u"Set lifetime membership?",
u"Do you really want to give '{}' a lifetime membership?".format(obj["success"]["name"].title()),
"warning",
)
if not check:
self.infotext.set(u"{} does NOT have a lifetime membership..".format(obj["success"]["name"].title()))
return
obj = self.storage.update(**{"id": id, "life": True})
if "error" in obj:
self.infotext.set(u"FAILURE! {}".format(obj["error"]))
elif "success" in obj:
self.infotext.set(u"Success! {}".format(obj["success"]))
self._populate_list()
def unset_lifetime(self):
"""
remove a lifetime membership from a user. The user is selected by clicking in the list.
"""
if not self.is_clicked:
self.infotext.set(u"FAILURE! No id provided. You have to click a person in the list!.")
return
id = self.clicked_id
self.is_clicked = False
self.clicked_id = -1
obj = self.storage.read(**{"id": id})
if "success" in obj:
check = self._popup(
u"Remove lifetime membership?",
u"Do you really want to remove '{}'s' lifetime membership?".format(obj["success"]["name"].title()),
"warning",
)
if not check:
self.infotext.set(u"{} is still a lifetime member.".format(obj["success"]["name"].title()))
return
obj = self.storage.update(**{"id": id, "life": False})
if "error" in obj:
self.infotext.set(u"FAILURE! {}".format(obj["error"]))
elif "success" in obj:
self.infotext.set(u"Success! {}".format(obj["success"]))
self._populate_list()
def update_id(self):
"""
Update the id of a user
"""
if not self.is_clicked:
self.infotext.set(u"FAILURE: You have to click a user in the list.")
return
newid = self._get_val()
if newid == "":
self.infotext.set(u"FAILURE: You have to enter a new id in the textfield.")
return
id = self.clicked_id
self.is_clicked = False
self.clicked_id = -1
name = self.storage.read(**{"id": id})
if not "success" in name:
self.infotext.set(u"FAILURE: id could not be found..")
return
name = u"{}".format(name["success"]["name"].title())
if not self._popup(u"Change id?", u"Do you really want to change the id of '{}'?".format(name)):
self.infotext.set(u"Aborted changing id.")
return
retval = self.storage.update_id(id, newid)
self.infotext.set(retval["status"])
self._populate_list()
def _get_val(self):
"""
clears the input-field and returns value that was there.
"""
val = self.omnibar.get()
self.omnibar.delete(0, END)
val = u"{}".format(val)
return val.lower()
def save_to_file(self, event=None):
val = self.storage.save()
self.infotext.set("{}".format(val["msg"]))
def _popup(self, title, text, style=None):
"""
create a popup!
:param title: title of the popup-window
:param text: the text in the popup-window
:param style: the icon-style of the popup. default is 'warning'
"""
if style:
if style == "error":
return tkMessageBox.showerror(title, text)
return tkMessageBox.askokcancel(title, text, icon=style)
return tkMessageBox.askokcancel(title, text)
class GameFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, width=600, height=250)
self.parent = parent
def init_gui(self):
correct = """R0lGODlhQABAAOeqAAAAAAABAAACAAADAAAEAAAFAAAFAQAGAQAHAQEHAQEIAQEJAQEKAQEKAgEL
AgEMAgENAgEPAgIPAgIQAgIRAwITAwIUAwIVBAMVBAIWAwIWBAIXBAMXBAMYAwIZBAMZBAMaBQMb
BAMdBQMeBQMfBQMgBQQgBQQiBgQkBgQlBgQmBwQnBwUnBgUoBwUqBwUrBwUsBwUsCAUtCAUuCAUv
CAYvCAUxCAYyCQYzCAY0CQY1CgY2CQY3CQc3CgY5Cgc5Cgc7Cgc+Cwg/CwdACwhACwhBCwhCCwhG
DAhHDAhIDQlLDQlMDglNDglPDglQDglRDglSDgpUDwpWDwtWDwpXDwpZDwtaEAtfEQtgEQthEQxk
EQxkEgxlEgxnEgxoEw1oEgxpEgxqEw1qEg1rEwxsEw1sEg1tEw1vEw1wFA1yFA5yFA1zFA50FA50
FQ51FA52FQ95Fg56FQ57Fg97FQ99Fg9+Fg9/Fg+AFhCAFg+BFhCCFhCEFxCGFxCHGBCIGBCKGBGK
GBCLGBGMGRGNGRGOGRGQGRGRGRGRGhGSGRGTGhKTGRKTGhGUGhKVGhKXGhKXGxKYGhKaGxKbGxKc
GxKdGxKdHBOdGxOdHBKeHBOeGxOeHBOfHBOgHBOhHBOiHBOiHROjHBOjHROkHRSkHROlHRSlHRSm
HRSnHRSoHRSrHv//////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////yH+EUNyZWF0ZWQgd2l0aCBH
SU1QACH5BAEKAP8ALAAAAABAAEAAAAj+AP8JHEiwoMGDCBMqPAhgocOHEB0CaBixosWFEyde3MhR
YEaKHUNC/CiyJMYHCTSaXGkQgAcVKVnKHAhgBZIIIGeanAiki4acOkVOlJInBNCgHQEIELOIxFGk
GwFASLNJxVOoFgFUiFOKx1WsEQFY0GOqiQCwIQF0ECSqi4KvaDGKWNRJjgW4cRMCOEGI06AWePMy
ROGnU6QggQUXBIBij6dPUBIrptk4lKkuAiRPBpCCT6hQdipoVgxgBB9PnAzBGC0YQAY7mzRJWsI6
L4AIazTpVkNg8kgFXDhpwqTorm+JA6aE0kRpk47acQEkMUVJU6cs0NEC8FGKEiVOfQb+ZMcKgMWk
TM0joRgPFQCIQMw1bXpy9rjC22+Ea+IUZwJ7pAZcIVx1jdjwX1AAKFHJJt5lgsWBOgGwAyScUHKJ
JoJIAKFMpRlSIXOj3LAhSwAkgMeHlIDixYgkauGdJpds4ggFLO5EhCOaWMKcKUMEEGFaJfzBoG6d
vAEBgipl9cAZoFRXXSQ41OgRAAHUJgATp1Sn2yZjJNBeARi8FZYMoGByoW6IrEbeD04Y9RAAFBwy
JHOYdCFlS1T8UQROCwVgxocwapIIB3cuBsAWppgxQ5KLGfGibpSI4kShLTnQRiqEWPHBUQCYAJ9u
zHHCxwGUtiQCH6RwYscRBOS0QBjKsYGqCSk1lMpQDoxs0okjaVjVEABCVBIfc6CwccBxADwxCaiF
VEHqBosAqhsnMdiaUABoDCsJIDq40YmZkIJCBgP2/VMiIAxWd4kkTsr6SA7W3ndBJMPJai8naSBQ
Lk0zxKalvZo00kO8DgXAxID2UmLJHARLtAAYsdorCQ0NS/TBHcMytwkdFb8JgyHDYuKJCx2/OcQm
mFhCSScM73tfFNRhMsoLJY+UwBeneAKHly7fZ0EdqOxQc0UAvFBGBT0/JEAD9SWN0XEBAQA7
"""
wrong = """R0lGODlhQABAAOexAAAAAAEAAAIAAAMAAAQAAAUAAAYAAAgAAAkAAAoAAAwAAA0AAA4AAA8AABAA
ABEAABIAABMAABQAABUAABYAABcAABgAABkAABoAABsAABwAAB0AAB4AAB8AACAAACEAACIAACMA
ACQAACUAACYAACgAACkAACoAACsAACwAAC0AAC4AADEAADMAADQAADUAADYAADgAADkAADoAADsA
ADwAAD0AAD4AAD8AAEEAAEIAAEQAAEUAAEkAAEoAAEsAAFQAAFUAAFgAAFkAAF0AAF8AAGEAAGIA
AGQAAGcAAGgAAGoAAGsAAG0AAG4AAG8AAHAAAHMAAHgAAHsAAHwAAIEAAIYAAIoAAI4AAJMAAJQA
AJUAAJYAAJcAAJgAAJkAAJoAAJsAAJwAAJ0AAJ4AAKAAAKEAAKQAAKcAAKgAAKkAAKoAAK0AAK4A
AK8AALAAALEAALMAALUAALcAALgAALkAALoAALsAAL4AAL8AAMAAAMEAAMQAAMUAAMYAAMgAAMkA
AMoAAMwAAM0AAM4AAM8AANAAANEAANIAANMAANQAANUAANYAANcAANgAANkAANoAANsAAN0AAN4A
AOAAAOEAAOIAAOMAAOQAAOYAAOgAAOkAAOoAAOwAAO0AAO4AAO8AAPAAAPEAAPIAAPMAAPQAAPUA
APYAAPcAAPgAAPkAAPoAAPsAAPwAAP0AAP4AAP8AAP//////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////yH+EUNyZWF0ZWQgd2l0aCBH
SU1QACH5BAEKAP8ALAAAAABAAEAAAAj+AP8JHEhwIAAABRMqXLjwIMOHCQFAgIAQosWGFjRUvNhQ
A5sxDTZyvAggwhpAK0SOFAigwxxXo7aEXGmxZBlSqwbFUMmx5Z1To0qN4oKAJ02DCsiQEmqKUA2j
DwFsoFOKFKlRpE55CQB1JQABZE5dtVqqEIyuES28STXW6ihWXxweNQhAzCqsVq+eMpQCrUEKamCN
wpt3VKsvBPwyBEDASyvChVcdKuEXQIU0giEXVtVFgWKFCbKo0lyY1SEVXQFcaJM5r+u8pbY4+ExQ
AZbXuK+uQjTDKAAMckaTdh00pueRCK6IEpqb+ClEOVSqliN0+OugpbgkrinASinmzYn+l0KEYyMA
Cm3EWseNVZUXuQ0BVFnVNvxrU4peIATQ4AzM9c0ZtlVqVAhmX4CpKBLCQR8UYkp9BxLHShdFKUTA
FDBFyB4ppugBwn4m8CGWhuydIpNKBkxhCoD2mXLHhwad8MeKJLKnBQMbFSAFKODVeJUpe4ggHQiH
0OjjVUJtcQBCAkTBI4u5jXLKIBz4VsEjQB05FipdHLTEKdUdKWUjE6QmQSMPQskeK1sQ4QqEGmJl
SiMSVKbBIOppOYoqj6lJXFaFbPAZACT0kaeYcEaI1SmBnEDbPwCgYKiWlOZ1iiAsPMoSCYMYWSmJ
QTGS0lwAaNBIlp8qWoolJGhaEAD+EjziaapRlpIJjHMZVEGRiaYqJyWU5foqCH8cSuuWjrTgalQn
iHisa6csYsOyEAFgAiCzVhqUJOUJG5UHiWSL6Ca9eVstBYw8mKonZ5lbUxOspJoKGvC5q1AASbDi
Z4CrgFGhvQkN0ESatI6CChgPUAvRAFB40uOxYkSg8EIBONGJuNpWZcYCE7+qxFKDPesWh2psZy4A
R7TS67F7viFAxwAg8UrIIrO3ShwJKCwAE6nQXDN7qLxBwbIDPBHKyj9bZUobGq0kwBOdPJz0dUvB
cQFtADARSpg+yrlvYRzaMVtNSLDlM6ikdJLu1yOfwse/DR0xM9tYlcLJCxIgQrD+mKgAMtO9SvSJ
6CmUTAsAB37s3TUqfmTA0wBOjKwlKpDsUBGheIyo5yl6tEoQw1Gz/eMkPIgEwAh5oKrlKXl4/s8B
DWN8IFaadPtqBn2gIrqcf6BwUAaCCIdoKDs1xMAfPW+uiQv7vaCIumiX8ol+USHg7NelYPKDeTgg
InWAWWFSbrUN1KG4fVhVIoR0OSCiOvioRKID1mpVxWJQlhDhmwyI3HXgKZEonVcywAboBegUmghC
alRwCH0FKHvzOwoAJuAG3R3QEz2oTAkM4T+qfWJ8EkwAHDronE9EsCYpKMT7sBIK6gkLAAFow2jE
wwkfPAoAMCBEVcZiCk0U72RWBEiD4jAxBFcBgAaEoBEqJmE7dwFgATcRSikuYQRqASAGg1DFKSAh
QIBBCgJh4NAmijAxAKxAEJiwnBcN4gAwdAIIHYNUB24Qx8U8QFn2guEaI/KZgAAAOw=="""
self.correct_img = PhotoImage(data=correct)
self.wrong_img = PhotoImage(data=wrong)
self.entry = Entry(self.parent, width=15,
font=('Helvetica', 20, 'normal'), justify=CENTER)
self.entry.bind("<Return>", lambda x:self.buttonSubmit.invoke())
self.buttonNext = Button(self.parent, width=10, text="Next Word",
command=self.next_word, state=DISABLED)
self.buttonSubmit = Button(self.parent, width=10, text="Submit",
command=self.submit_word)
buttonReplay = Button(self.parent, width=10, text="Repeat Word",
command=self.replay_word)
self.game_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.word_display = self.game_canvas.create_text((300, 105), text="?",
font=("Helvetica", 50, "bold"), fill="#004183")
self.progress_display = self.game_canvas.create_text((593, 5),
text="%d/%d"%(1, self.parent.list_length),
font=("Helvetica", 25, "bold"), anchor=NE)
self.timer_display = self.game_canvas.create_text(10, 5, anchor=NW,
font=("Helvetica", 25))
self.progress_bar = ProgressBar(self, width=300,
increments=len(self.parent.current_list.words))
self.game_canvas.create_window(500, 10, anchor=NE, window=self.progress_bar)
self.game_canvas.create_window(300, 180, window=self.entry)
self.game_canvas_image = self.game_canvas.create_image(500, 170)
self.game_canvas.create_window(150, 230, window=buttonReplay)
self.game_canvas.create_window(300, 230, window=self.buttonSubmit)
self.game_canvas.create_window(450, 230, window=self.buttonNext)
self.game_canvas.pack()
def start(self):
self.current_list_iter = iter(self.parent.current_list.words)
self.current_word = self.current_list_iter.next()
self.parent.festival.speech(self.current_word)
self.time_elapsed = 0
self.init_gui()
self.tick()
def next_word(self):
try:
self.current_word = self.current_list_iter.next()
index = self.parent.current_list.words.index(self.current_word) + 1
self.game_canvas.itemconfig(self.progress_display, text="%d/%d"
%(index, self.parent.list_length))
if index == self.parent.list_length:
self.buttonNext.configure(text="Finish")
self.game_canvas.itemconfig(self.word_display, text="?", fill="#004183")
self.game_canvas.itemconfig(self.game_canvas_image, state=HIDDEN)
self.buttonSubmit.configure(state=NORMAL)
self.buttonNext.configure(state=DISABLED)
self.parent.festival.speech(self.current_word)
except StopIteration:
self.list_complete()
def list_complete(self):
self.parent.after_cancel(self.timer)
self.parent.show_results(self.time_elapsed)
def replay_word(self):
self.parent.festival.speech(self.current_word)
def submit_word(self, event=None):
guess = self.entry.get()
self.entry.delete(0, END)
if guess == self.current_word.word:
self.correct(guess)
else:
self.incorrect(guess)
self.game_canvas.itemconfig(self.word_display, text='%s'%(self.current_word))
self.buttonNext.configure(state=NORMAL)
self.buttonSubmit.configure(state=DISABLED)
self.game_canvas.itemconfig(self.game_canvas_image, state=NORMAL)
def correct(self, guess):
self.current_word.setAnswer(guess, True)
self.game_canvas.itemconfig(self.game_canvas_image, image=self.correct_img)
self.game_canvas.itemconfig(self.word_display, fill="#139E1C")
self.progress_bar.increment(True)
def incorrect(self, guess):
self.current_word.setAnswer(guess, False)
self.game_canvas.itemconfig(self.game_canvas_image, image=self.wrong_img)
self.game_canvas.itemconfig(self.word_display, fill="#F30000")
self.progress_bar.increment(False)
def tick(self):
seconds = (self.time_elapsed)%60
minutes = self.time_elapsed/60
separator = ":" if seconds > 9 else ":0"
formatted_time = "%d%s%d"%(minutes, separator, seconds)
self.game_canvas.itemconfig(self.timer_display, text=formatted_time)
self.time_elapsed +=1
self.timer = self.parent.after(1000, self.tick)
class ConnectionUI(Frame):
"""
Initial name and port dialogue UI.
In case of incorrect inputs, the user is notified via error messages and is allowed to continue
providing inputs.
"""
nickname = None
port = None
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.row, self.col = -1, -1
self.__initUI()
def __initUI(self):
"""
Initialize UI with two entry fields and a connection button."""
self.parent.title('Connect to a Sudoku server')
self.pack(fill=BOTH, expand=1)
Label(self, text='Enter Nickname').grid(row=0, padx=(15, 0))
Label(self, text='Nickname presets').grid(row=1, padx=(15, 0))
Label(self, text='Enter Sudoku server port').grid(row=2, padx=(15, 0))
self.entry_nickname = Entry(self)
self.entry_nickname.grid(row=0, column=1, padx=(0, 15))
var = StringVar(self)
var.set('')
self.entry_nickname_options = OptionMenu(self,
var,
'Peeter',
'Jürka',
'Antskan',
'Jüri',
'Toss',
command=self.__select_preset)
self.entry_nickname_options.grid(row=1, column=1, padx=(0, 15))
self.entry_port = Entry(self)
self.entry_port.grid(row=2, column=1, padx=(0, 15))
self.submit_name = Button(self,
text='Submit and connect',
command=self.__submit_connect)
self.submit_name.grid(row=3, column=1)
def __submit_connect(self):
"""
Input name has no space and less or equal to 8 characters.
Input port consists of an integer between 1001 and 65535.
"""
name_ok = False
port_ok = False
nickname = self.entry_nickname.get()
if 8 >= len(nickname) > 0:
if ' ' not in nickname:
name_ok = True
LOG.debug('Player created: ' + nickname)
else:
tkMessageBox.showwarning("Name error",
"Player name cannot contain space.")
elif len(nickname) <= 0:
tkMessageBox.showwarning("Name error",
"Player name cannot be empty.")
elif len(nickname) > 8:
tkMessageBox.showwarning(
"Name error",
"Player name has to be less than 9 characters long.")
try:
port = int(self.entry_port.get())
except (ValueError, TypeError):
port = '-1'
if isinstance(port, int):
if 1000 < port < 65535:
port_ok = True
LOG.debug('Ok port.')
else:
tkMessageBox.showwarning(
"Port error",
"Port number has to be between 1000 and 65535.")
else:
tkMessageBox.showwarning("Port error",
"Port number has to be an integer.")
if name_ok and port_ok:
self.nickname = nickname
self.port = port
def __select_preset(self, value):
"""
Selects one of the preset names as the nickname """
self.entry_nickname.delete(0, 'end')
self.entry_nickname.insert('end', value)
class tkFileSelector() :
def __init__(self,master,start_dir=expanduser("~"),filetypes=[],title="Select a music file.",color_1="#000000",color_2="#00c0c0",highlight_color_items="#c9c9c9") :
'''
master == root_window == Tk()
use color_1 and color_2 and bg_items and fg_items and highlight_color_items for colors personalisation.
filetypes must "Strictly" be a list of extension beginning with an asterix followed by a point and the extension (in lowercase) or an empty list for no filtering.
filetypes=["*.mp3","*.wav"] per example. Or insert an, item '*' for all filetype in combination with defined filetypes.
for borderwidth and relief settings look at the code
'''
# Constrcut GUI for the file selection toplevel.
self.toplevel=Toplevel(master,bg=color_1,borderwidth=1,relief="sunken")
self.toplevel.resizable(width=False, height=False)
self.toplevel.title(title)
self.dir_selection_frame=Frame(self.toplevel,bg=color_1,borderwidth=8/2,relief="groove") # Frame container for directory fields.
self.dir_name_entry=Entry(self.toplevel,justify="center",width=50,bg=color_2,fg=color_1) # This will contains the current directory relative dirname
self.dir_name_separator=Button(self.toplevel,width=1,relief="sunken",bg=color_1,fg=color_2) # An separator
self.dir_back_button=Button(self.toplevel,width=6,relief="raised",bg=color_2,fg=color_1,text="Back",command=self.folder_go_back) # Change directory back button.
self.canvas_frame=Frame(self.toplevel,borderwidth=8,relief="groove") # Frame for the file selection window canvas and his scrollbar.
self.canvas=Canvas(self.canvas_frame,height=20*9,width=18*28,bg=color_2) # File selection window.
self.canvas_scrollbar=Scrollbar(self.canvas_frame,orient=HORIZONTAL, bg=color_2,troughcolor=color_1,command=self.canvas.xview) # File selection window scrollbar.
self.canvas.configure(xscrollcommand=self.canvas_scrollbar.set)
self.file_selection_frame=Frame(self.toplevel,bg=color_1,borderwidth=8/2,relief="groove") # Frame container for filename fields.
self.file_name_entry=Entry(self.toplevel,justify="center",width=50,bg=color_2,fg=color_1) # This will contains the basename (relative) of the selected file.
self.file_name_separator=Button(self.toplevel,width=1,relief="sunken",bg=color_1,fg=color_2) # An separator.
self.file_filter_menubutton = Menubutton(self.file_selection_frame, text='',relief="groove",width=8,bg=color_2,fg=color_1) # Menubutton for filetype filter.
self.file_filter_extension=""
if filetypes :
self.file_filter_menu= Menu(self.file_filter_menubutton,borderwidth=3,relief="groove") # We use a menu for the filetypes filtering.
i=0
self.file_filter_var=StringVar(master=None, value=filetypes[i], name=None) # Control varaible for current filetype and initialize with the first filetype item.
self.file_filter_menubutton.config(text=filetypes[i])
self.file_filter_extension=filetypes[i][1::]
while i < len(filetypes) :
# Creating radiobutton to change the filetype filter.
self.file_filter_menu.add_radiobutton(label=filetypes[i], variable=self.file_filter_var,value=filetypes[i],background=color_2,command=self.set_filetype_filter )
i += 1
self.file_filter_menubutton.configure(menu= self.file_filter_menu)
self.buttons_frame=Frame(self.toplevel,bg=color_2,borderwidth=8,relief="groove",height=50,width=18*3) # Frame container for the buttons.
self.button_cancel=Button(self.buttons_frame,bg=color_2,fg=color_1,text="Quit",borderwidth=8/2,relief="groove",width=8,command=self.item_selection_quit)
self.button_home=Button(self.buttons_frame,bg=color_2,fg=color_1,text="Home",borderwidth=8/2,relief="groove",width=8,command=self.item_selection_home)
self.button_ok=Button(self.buttons_frame,bg=color_2,fg=color_1,text=" OK ",borderwidth=8/2,relief="groove",width=8,command=self.item_selection_ok)
self.start_dir=start_dir # Start folder.
self.curdir=start_dir # Current folder.
self.last_dir=[] # Container for the precedent folders we visit.
self.last_dir.append(start_dir) # Append start folder.
self.select_filepath="" # Value to return by file selection.
self.dir_name_entry.insert(0,"../"+basename(self.curdir))
if not color_2 :
self.items_bg="#D9D9D9"
else :
self.items_bg=color_2
self.items_fg=color_1
self.highlight_color_items=highlight_color_items
self.init_icons()
self.ls_dir()
self.update_canvas()
self.dir_selection_frame.grid(row=0,column=0,sticky="WE")
self.dir_name_entry.grid(row=0,column=0,in_=self.dir_selection_frame,sticky="NSEW")
self.dir_name_separator.grid(row=0,column=1,in_=self.dir_selection_frame,sticky="EW")
self.dir_back_button.grid(row=0,column=2,in_=self.dir_selection_frame,sticky="EW")
self.canvas_frame.grid(row=1,column=0,sticky="WE")
self.canvas.grid(row=0,column=0,in_=self.canvas_frame)
self.canvas_scrollbar.grid(row=1,column=0,in_=self.canvas_frame,sticky="WE")
self.file_selection_frame.grid(row=2,column=0,sticky="WE")
self.file_name_entry.grid(row=0,column=0,in_=self.file_selection_frame,sticky="NSEW")
self.file_name_separator.grid(row=0,column=1,in_=self.file_selection_frame,sticky="EW")
self.file_filter_menubutton.grid(row=0,column=2,in_=self.file_selection_frame,sticky="NS")
self.buttons_frame.grid(row=3,column=0,sticky="NSEW")
self.button_cancel.grid(row=0,column=2,padx=32+3,pady=4,in_=self.buttons_frame)
self.button_home.grid(row=0,column=4,padx=32+3,pady=4,in_=self.buttons_frame)
self.button_ok.grid(row=0,column=6,padx=34+3,pady=4,in_=self.buttons_frame)
self.toplevel.wait_window()
def init_icons(self) :
# Folder and file icons, design by me.
self.image_folder=Image.open("/usr/share/ScreenLocker/Images/file_selector/folder_icon.png")
self.imagetk_folder=ImageTk.PhotoImage(image=self.image_folder)
self.image_file=Image.open("/usr/share/ScreenLocker/Images/file_selector/file_icon.png")
self.imagetk_file=ImageTk.PhotoImage(image=self.image_file)
def ls_dir(self) :
''' List an directory and split the result in folders and files containers.
Finally sort the 2 containers.'''
folder_content=listdir(self.curdir)
self.cur_folder_entries=len(folder_content)
self.cur_folder_list=[]
self.cur_files_list=[]
folder_content.sort()
for v in folder_content :
if isdir(self.curdir+"/"+v) :
self.cur_folder_list.append(unicode(v,encoding='utf-8'))
elif isfile(self.curdir+"/"+v) :
self.cur_files_list.append(unicode(v,encoding='utf-8'))
self.cur_folder_list.sort()
self.cur_files_list.sort()
def update_canvas(self) :
''' Generating the content from the File selection window (an canvas)'''
self.clear_canvas()
i=0 # global folder and file iterator.
pos_x=0 # Coordinates for the rows.
pos_y=0 # Coordinates in the columns.
max_len=0 # Column max folder|filename length.
max_len_save=0 # Saved value for filling empty canvas scrollregion.
while i < len(self.cur_folder_list) :
# Generating the folder items of the current folder
exec(u"folder_icon_{0}=Label(self.canvas,text='{1}',image=self.imagetk_folder,relief='flat',width=17,height=17,bg=self.items_bg)".format(str(i),self.cur_folder_list[i].replace("'","\\'")))
exec(u"folder_name_{0}=Label(self.canvas,text='{1}',relief='flat',width={2},font='Monospace 9 bold',justify='left',bg=self.items_bg,fg=self.items_fg)".format(str(i),self.cur_folder_list[i].replace("'","\\'"),int(len(" "+self.cur_folder_list[i]))))
if int(len(" "+self.cur_folder_list[i])) > max_len :
# Update longest folder name in this column.
max_len=int(len(" "+self.cur_folder_list[i])) # Storing the value for max length of the longest folder name in this column.
max_len_save=max_len # Value to save for filling if the generating content take minus place as the canvas scrollregion.
exec("folder_icon_{0}.bind('<Double-1>',self.select_folder)".format(str(i)))
exec("folder_name_{0}.bind('<Double-1>',self.select_folder)".format(str(i)))
exec("folder_name_{0}.bind('<Enter>',self.highlight_item_enter)".format(str(i)))
exec("folder_name_{0}.bind('<Leave>',self.highlight_item_leave)".format(str(i)))
exec("folder_icon_{0}.pack(side='left',fill=BOTH)".format(str(i)))
exec("folder_name_{0}.pack(side='right',fill=BOTH)".format(str(i)))
exec("self.canvas.create_window(({1},{2}),anchor='nw',window=folder_icon_{0})".format(str(i),pos_x,pos_y))
exec("self.canvas.create_window(({1}+17+1,{2}),anchor='nw',window=folder_name_{0})".format(str(i),pos_x,pos_y))
pos_y += 20 # column increment 17 height of an items + 3 pixels padding.
if ( i % 9 == 0) and not i == 0 :
# An column can contains 9 items and we change column.
pos_y=0 # Column position updating.
pos_x += 17 + (max_len*9) # Update the x coordinates according the maximal length of foldername in this column ( (9 pixels == font size) (17 pixels for the folder item icon) ) .
max_len=0
i += 1 # Go to the next item.
ii=0 # Files iterator.
while ii < len(self.cur_files_list) :
# Generating the files items of the current folder.
if (self.file_filter_extension and self.cur_files_list[ii].lower().endswith(self.file_filter_extension)) or not self.file_filter_extension :
# applying filter of no filetype filering.
exec(u"file_icon_{0}=Label(self.canvas,text='{1}',image=self.imagetk_file,relief='flat',width=17,height=17,bg=self.items_bg)".format(str(i),self.cur_files_list[ii].replace("'","\\'")))
exec(u"file_name_{0}=Label(self.canvas,text='{1}',relief='flat',width={2},font='Monospace 9 normal',justify='left',bg=self.items_bg,fg=self.items_fg)".format(str(i),self.cur_files_list[ii].replace("'","\\'"),int(len(" "+self.cur_files_list[ii]))))
if int(len(" "+self.cur_files_list[ii])) > max_len :
# Update longest filename in this column.
max_len=int(len(" "+self.cur_files_list[ii])) # Storing the value for max length of the longest filename in this column.
max_len_save=max_len # Value to save for filling if the generating content take minus place as the canvas scrollregion.
exec("file_icon_{0}.bind('<Double-1>',self.select_file)".format(str(i)))
exec("file_name_{0}.bind('<Double-1>',self.select_file)".format(str(i)))
exec("file_name_{0}.bind('<Enter>',self.highlight_item_enter)".format(str(i)))
exec("file_name_{0}.bind('<Leave>',self.highlight_item_leave)".format(str(i)))
exec("file_icon_{0}.pack(side='left',fill=BOTH)".format(str(i)))
exec("file_name_{0}.pack(side='right',fill=BOTH)".format(str(i)))
exec("self.canvas.create_window(({1},{2}),anchor='nw',window=file_icon_{0})".format(str(i),pos_x,pos_y))
exec("self.canvas.create_window(({1}+17+1,{2}),anchor='nw',window=file_name_{0})".format(str(i),pos_x,pos_y))
pos_y += 20 # column increment 17 height of an items + 3 pixels padding.
if ( i % 9 == 0) and not i == 0 :
# An column can contains 9 items and we change column.
# Note: we check the common file & folder iterator.
pos_y=0 # Column position updating.
pos_x += 17 + (max_len*9) # Update the x coordinates according the maximal length of filename in this column ( (9 pixels == font size) (17 pixels for the file item icon) ).
max_len=0
i += 1
ii += 1
if not pos_x+(max_len_save*9)+17 < 18*28 :
# items collection greater than the canvas scrollregion.
self.canvas.config(scrollregion=(0,0,pos_x+(max_len_save*9)+17,0))
else :
# items collection littler than the canvas scrollregion.
self.canvas.config(scrollregion=(0,0,18*28,0))
def clear_canvas(self) :
for child in self.canvas.children.values() :
child.destroy()
def highlight_item_enter(self,event) :
event.widget.config(bg=self.highlight_color_items)
def highlight_item_leave(self,event) :
event.widget.config(bg=self.items_bg)
def select_folder(self,event) :
if isdir(self.curdir+"/"+event.widget.cget("text").lstrip()) : # event.widget.cget("text") return the selected folder. sea the update_canvas() method.
self.select_filepath=""
self.file_name_entry.delete(0,END)
if self.curdir.startswith('//') :
# Bugfix.
self.curdir=self.curdir[1::]
self.last_dir.append(self.curdir)
else :
self.last_dir.append(self.curdir)
for v in self.last_dir :
# Bigfix
if self.last_dir.count(v) > 1 :
self.last_dir.remove(v)
try :
# in case of access right this will fail immediatelly
listdir(self.curdir+"/"+event.widget.cget("text"))
self.curdir=self.curdir+"/"+event.widget.cget("text")
self.dir_name_entry.delete(0,END)
self.dir_name_entry.insert(0,"../"+event.widget.cget("text"))
self.ls_dir()
self.update_canvas()
except :
pass
def select_file(self,event) :
if isfile(self.curdir+"/"+event.widget.cget("text")) :
# Set the value to return and fill the file selection field.
self.select_filepath=self.curdir+"/"+event.widget.cget("text")
self.file_name_entry.delete(0,END)
self.file_name_entry.insert(0,event.widget.cget("text"))
def folder_go_back(self) :
if len(self.last_dir) > 1 :
self.curdir=self.last_dir.pop(-1) # pop the last value from the visited folder folders
else :
# In case we have yet only 1 folder in the visited folder container.
if self.last_dir[0].rfind("/") :
# The value of the container is not the root folder ( / ) but not the /home/username folder who can be only visited folder.
self.last_dir[0]=self.last_dir[0][0:self.last_dir[0].rfind("/")]
self.curdir=self.last_dir[0]
elif self.last_dir[0].rfind("/") == 0 :
# The value of the container is the root folder.
self.last_dir[0]="/"
self.curdir=self.last_dir[0]
else :
# The value is the /home/username directory
self.curdir=self.last_dir[0]
self.file_name_entry.delete(0,END)
self.select_filepath=""
self.dir_name_entry.delete(0,END)
self.dir_name_entry.insert(0,"../"+basename(self.curdir))
self.ls_dir()
self.update_canvas()
def set_filetype_filter(self) :
'''Change filetype filter.'''
self.file_filter_menubutton.config(text=self.file_filter_var.get())
self.file_filter_extension=self.file_filter_var.get()[1::] # Contains the selected filetype ( in form '.'+filetype ).
self.file_name_entry.delete(0,END)
self.select_filepath=""
self.ls_dir()
self.update_canvas()
def item_selection_ok(self) :
'''Return the selected filepath or empty string
and destroy File_selector instance'''
if self.select_filepath :
self.toplevel.destroy()
return True
def item_selection_quit(self) :
'''destroy File_selector instance'''
self.toplevel.destroy()
return False
def item_selection_home(self) :
'''Change current directory to the /home/username folder'''
self.curdir=expanduser("~")
self.select_filepath=""
self.file_name_entry.delete(0,END)
self.last_dir=[]
self.last_dir.append(expanduser("~"))
self.dir_name_entry.delete(0,END)
self.dir_name_entry.insert(0,"../"+basename(self.curdir))
self.ls_dir()
self.update_canvas()
class ConcordanceSearchView(object):
_BACKGROUND_COLOUR = '#FFF' #white
#Colour of highlighted results
_HIGHLIGHT_WORD_COLOUR = '#F00' #red
_HIGHLIGHT_WORD_TAG = 'HL_WRD_TAG'
_HIGHLIGHT_LABEL_COLOUR = '#C0C0C0' # dark grey
_HIGHLIGHT_LABEL_TAG = 'HL_LBL_TAG'
#Percentage of text left of the scrollbar position
_FRACTION_LEFT_TEXT = 0.30
def __init__(self):
self.model = ConcordanceSearchModel()
self.model.add_listener(self)
self.top = Tk()
self._init_top(self.top)
self._init_menubar()
self._init_widgets(self.top)
self._bind_event_handlers()
self.load_corpus(self.model.DEFAULT_CORPUS)
def _init_top(self, top):
top.geometry('950x680+50+50')
top.title('NLTK Concordance Search')
top.bind('<Control-q>', self.destroy)
top.minsize(950, 680)
def _init_widgets(self, parent):
self.main_frame = Frame(
parent,
dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1))
self._init_corpus_select(self.main_frame)
self._init_query_box(self.main_frame)
self._init_results_box(self.main_frame)
self._init_paging(self.main_frame)
self._init_status(self.main_frame)
self.main_frame.pack(fill='both', expand=True)
def _init_menubar(self):
self._result_size = IntVar(self.top)
self._cntx_bf_len = IntVar(self.top)
self._cntx_af_len = IntVar(self.top)
menubar = Menu(self.top)
filemenu = Menu(menubar, tearoff=0, borderwidth=0)
filemenu.add_command(label='Exit',
underline=1,
command=self.destroy,
accelerator='Ctrl-q')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
rescntmenu = Menu(editmenu, tearoff=0)
rescntmenu.add_radiobutton(label='20',
variable=self._result_size,
underline=0,
value=20,
command=self.set_result_size)
rescntmenu.add_radiobutton(label='50',
variable=self._result_size,
underline=0,
value=50,
command=self.set_result_size)
rescntmenu.add_radiobutton(label='100',
variable=self._result_size,
underline=0,
value=100,
command=self.set_result_size)
rescntmenu.invoke(1)
editmenu.add_cascade(label='Result Count',
underline=0,
menu=rescntmenu)
cntxmenu = Menu(editmenu, tearoff=0)
cntxbfmenu = Menu(cntxmenu, tearoff=0)
cntxbfmenu.add_radiobutton(label='60 characters',
variable=self._cntx_bf_len,
underline=0,
value=60,
command=self.set_cntx_bf_len)
cntxbfmenu.add_radiobutton(label='80 characters',
variable=self._cntx_bf_len,
underline=0,
value=80,
command=self.set_cntx_bf_len)
cntxbfmenu.add_radiobutton(label='100 characters',
variable=self._cntx_bf_len,
underline=0,
value=100,
command=self.set_cntx_bf_len)
cntxbfmenu.invoke(1)
cntxmenu.add_cascade(label='Before', underline=0, menu=cntxbfmenu)
cntxafmenu = Menu(cntxmenu, tearoff=0)
cntxafmenu.add_radiobutton(label='70 characters',
variable=self._cntx_af_len,
underline=0,
value=70,
command=self.set_cntx_af_len)
cntxafmenu.add_radiobutton(label='90 characters',
variable=self._cntx_af_len,
underline=0,
value=90,
command=self.set_cntx_af_len)
cntxafmenu.add_radiobutton(label='110 characters',
variable=self._cntx_af_len,
underline=0,
value=110,
command=self.set_cntx_af_len)
cntxafmenu.invoke(1)
cntxmenu.add_cascade(label='After', underline=0, menu=cntxafmenu)
editmenu.add_cascade(label='Context', underline=0, menu=cntxmenu)
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
self.top.config(menu=menubar)
def set_result_size(self, **kwargs):
self.model.result_count = self._result_size.get()
def set_cntx_af_len(self, **kwargs):
self._char_after = self._cntx_af_len.get()
def set_cntx_bf_len(self, **kwargs):
self._char_before = self._cntx_bf_len.get()
def _init_corpus_select(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.var = StringVar(innerframe)
self.var.set(self.model.DEFAULT_CORPUS)
Label(innerframe,
justify=LEFT,
text=' Corpus: ',
background=self._BACKGROUND_COLOUR,
padx=2,
pady=1,
border=0).pack(side='left')
other_corpora = self.model.CORPORA.keys().remove(
self.model.DEFAULT_CORPUS)
om = OptionMenu(innerframe,
self.var,
self.model.DEFAULT_CORPUS,
command=self.corpus_selected,
*self.model.non_default_corpora())
om['borderwidth'] = 0
om['highlightthickness'] = 1
om.pack(side='left')
innerframe.pack(side='top', fill='x', anchor='n')
def _init_status(self, parent):
self.status = Label(parent,
justify=LEFT,
relief=SUNKEN,
background=self._BACKGROUND_COLOUR,
border=0,
padx=1,
pady=0)
self.status.pack(side='top', anchor='sw')
def _init_query_box(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
another = Frame(innerframe, background=self._BACKGROUND_COLOUR)
self.query_box = Entry(another, width=60)
self.query_box.pack(side='left', fill='x', pady=25, anchor='center')
self.search_button = Button(another,
text='Search',
command=self.search,
borderwidth=1,
highlightthickness=1)
self.search_button.pack(side='left',
fill='x',
pady=25,
anchor='center')
self.query_box.bind('<KeyPress-Return>',
self.search_enter_keypress_handler)
another.pack()
innerframe.pack(side='top', fill='x', anchor='n')
def search_enter_keypress_handler(self, *event):
self.search()
def _init_results_box(self, parent):
innerframe = Frame(parent)
i1 = Frame(innerframe)
i2 = Frame(innerframe)
vscrollbar = Scrollbar(i1, borderwidth=1)
hscrollbar = Scrollbar(i2, borderwidth=1, orient='horiz')
self.results_box = Text(i1,
font=tkFont.Font(family='courier', size='16'),
state='disabled',
borderwidth=1,
yscrollcommand=vscrollbar.set,
xscrollcommand=hscrollbar.set,
wrap='none',
width='40',
height='20',
exportselection=1)
self.results_box.pack(side='left', fill='both', expand=True)
self.results_box.tag_config(self._HIGHLIGHT_WORD_TAG,
foreground=self._HIGHLIGHT_WORD_COLOUR)
self.results_box.tag_config(self._HIGHLIGHT_LABEL_TAG,
foreground=self._HIGHLIGHT_LABEL_COLOUR)
vscrollbar.pack(side='left', fill='y', anchor='e')
vscrollbar.config(command=self.results_box.yview)
hscrollbar.pack(side='left', fill='x', expand=True, anchor='w')
hscrollbar.config(command=self.results_box.xview)
#there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
Label(i2, text=' ',
background=self._BACKGROUND_COLOUR).pack(side='left', anchor='e')
i1.pack(side='top', fill='both', expand=True, anchor='n')
i2.pack(side='bottom', fill='x', anchor='s')
innerframe.pack(side='top', fill='both', expand=True)
def _init_paging(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.prev = prev = Button(innerframe,
text='Previous',
command=self.previous,
width='10',
borderwidth=1,
highlightthickness=1,
state='disabled')
prev.pack(side='left', anchor='center')
self.next = next = Button(innerframe,
text='Next',
command=self.next,
width='10',
borderwidth=1,
highlightthickness=1,
state='disabled')
next.pack(side='right', anchor='center')
innerframe.pack(side='top', fill='y')
self.current_page = 0
def previous(self):
self.clear_results_box()
self.freeze_editable()
self.model.prev(self.current_page - 1)
def next(self):
self.clear_results_box()
self.freeze_editable()
self.model.next(self.current_page + 1)
def about(self, *e):
ABOUT = ("NLTK Concordance Search Demo\n")
TITLE = 'About: NLTK Concordance Search Demo'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE, parent=self.main_frame).show()
except:
ShowText(self.top, TITLE, ABOUT)
def _bind_event_handlers(self):
self.top.bind(CORPUS_LOADED_EVENT, self.handle_corpus_loaded)
self.top.bind(SEARCH_TERMINATED_EVENT, self.handle_search_terminated)
self.top.bind(SEARCH_ERROR_EVENT, self.handle_search_error)
self.top.bind(ERROR_LOADING_CORPUS_EVENT,
self.handle_error_loading_corpus)
def handle_error_loading_corpus(self, event):
self.status['text'] = 'Error in loading ' + self.var.get()
self.unfreeze_editable()
self.clear_all()
self.freeze_editable()
def handle_corpus_loaded(self, event):
self.status['text'] = self.var.get() + ' is loaded'
self.unfreeze_editable()
self.clear_all()
self.query_box.focus_set()
def handle_search_terminated(self, event):
#todo: refactor the model such that it is less state sensitive
results = self.model.get_results()
self.write_results(results)
self.status['text'] = ''
if len(results) == 0:
self.status['text'] = 'No results found for ' + self.model.query
else:
self.current_page = self.model.last_requested_page
self.unfreeze_editable()
self.results_box.xview_moveto(self._FRACTION_LEFT_TEXT)
def handle_search_error(self, event):
self.status['text'] = 'Error in query ' + self.model.query
self.unfreeze_editable()
def corpus_selected(self, *args):
new_selection = self.var.get()
self.load_corpus(new_selection)
def load_corpus(self, selection):
if self.model.selected_corpus != selection:
self.status['text'] = 'Loading ' + selection + '...'
self.freeze_editable()
self.model.load_corpus(selection)
def search(self):
self.current_page = 0
self.clear_results_box()
self.model.reset_results()
query = self.query_box.get()
if (len(query.strip()) == 0): return
self.status['text'] = 'Searching for ' + query
self.freeze_editable()
self.model.search(
query,
self.current_page + 1,
)
def write_results(self, results):
self.results_box['state'] = 'normal'
row = 1
for each in results:
sent, pos1, pos2 = each[0].strip(), each[1], each[2]
if len(sent) != 0:
if (pos1 < self._char_before):
sent, pos1, pos2 = self.pad(sent, pos1, pos2)
sentence = sent[pos1 - self._char_before:pos1 +
self._char_after]
if not row == len(results):
sentence += '\n'
self.results_box.insert(str(row) + '.0', sentence)
word_markers, label_markers = self.words_and_labels(
sent, pos1, pos2)
for marker in word_markers:
self.results_box.tag_add(self._HIGHLIGHT_WORD_TAG,
str(row) + '.' + str(marker[0]),
str(row) + '.' + str(marker[1]))
for marker in label_markers:
self.results_box.tag_add(self._HIGHLIGHT_LABEL_TAG,
str(row) + '.' + str(marker[0]),
str(row) + '.' + str(marker[1]))
row += 1
self.results_box['state'] = 'disabled'
def words_and_labels(self, sentence, pos1, pos2):
search_exp = sentence[pos1:pos2]
words, labels = [], []
labeled_words = search_exp.split(' ')
index = 0
for each in labeled_words:
if each == '':
index += 1
else:
word, label = each.split('/')
words.append((self._char_before + index,
self._char_before + index + len(word)))
index += len(word) + 1
labels.append((self._char_before + index,
self._char_before + index + len(label)))
index += len(label)
index += 1
return words, labels
def pad(self, sent, hstart, hend):
if hstart >= self._char_before:
return sent, hstart, hend
d = self._char_before - hstart
sent = ''.join([' '] * d) + sent
return sent, hstart + d, hend + d
def destroy(self, *e):
if self.top is None: return
self.top.destroy()
self.top = None
def clear_all(self):
self.query_box.delete(0, END)
self.model.reset_query()
self.clear_results_box()
def clear_results_box(self):
self.results_box['state'] = 'normal'
self.results_box.delete("1.0", END)
self.results_box['state'] = 'disabled'
def freeze_editable(self):
self.query_box['state'] = 'disabled'
self.search_button['state'] = 'disabled'
self.prev['state'] = 'disabled'
self.next['state'] = 'disabled'
def unfreeze_editable(self):
self.query_box['state'] = 'normal'
self.search_button['state'] = 'normal'
self.set_paging_button_states()
def set_paging_button_states(self):
if self.current_page == 0 or self.current_page == 1:
self.prev['state'] = 'disabled'
else:
self.prev['state'] = 'normal'
if self.model.has_more_pages(self.current_page):
self.next['state'] = 'normal'
else:
self.next['state'] = 'disabled'
def fire_event(self, event):
#Firing an event so that rendering of widgets happen in the mainloop thread
self.top.event_generate(event, when='tail')
def mainloop(self, *args, **kwargs):
if in_idle(): return
self.top.mainloop(*args, **kwargs)
class DroneGUI:
def __init__(self, master):
self.master = master
master.title("Drone GUI")
## Initialising framework of GUI
frame1 = Frame(master, height=350, width=210, bd=2, relief="sunken")
frame1.grid(row=10, column=2, rowspan=6)
frame1.grid_propagate(False)
## Buttons
self.select_target_button = Button(master,
text="Select target",
command=self.select_target)
self.select_target_button.grid(row=4, column=2)
self.start_auto_button = Button(master,
text="Start autonomous flight",
command=self.start_autonomous)
self.start_auto_button.grid(row=5, column=2)
self.approach_button = Button(master,
text="Approach target",
command=self.set_approach)
self.approach_button.grid(row=6, column=2)
self.e1 = Entry(master)
self.e1.grid(row=7, column=2)
self.e1.bind("<Return>", self.get_target_distance)
self.close_button = Button(master,
text="Close",
command=self.close_gui)
self.close_button.grid(row=8, column=2)
self.battery_label = Label(master, text="Battery level: NA")
self.battery_label.grid(row=10, column=2)
self.x_distance_label = Label(master, text="X Distance: NA")
self.x_distance_label.grid(row=11, column=2)
self.y_distance_label = Label(master, text="Y Distance: NA")
self.y_distance_label.grid(row=12, column=2)
self.z_distance_label = Label(master, text="Z Distance: NA")
self.z_distance_label.grid(row=13, column=2)
self.yaw_distance_label = Label(master, text="Yaw angle: NA")
self.yaw_distance_label.grid(row=14, column=2)
self.flight_status_label = Label(master, text="Autonomous mode: 0")
self.flight_status_label.grid(row=15, column=2)
header_label = Label(master, text="Choosing target for drone")
header_label.grid(row=1, column=5)
self.bb_data = (None, None, None, None)
self.image_label = Label(text="", height=720, width=1280)
# self.image_label = Label(text = "", height = 480, width = 640)
# self.image_label = Label(text = "", height = 448, width = 800)
# self.image_label = Label(text = "", height = 1200, width = 1600)
self.image_label.grid(row=3, column=5, columnspan=15, rowspan=15)
self.control_status = 0
self.xTarget = 0
## Initialising variables for selecting target
self.imgClick = False
self.bridge = CvBridge()
self.enable_video_stream = None
self.prev_img = None
self.select_target_bool = False
self.circle_center = [None, None]
self.pos_x = -1
self.pos_y = -1
# Subscribers
self.battery_sub = rospy.Subscriber('/dji_sdk/battery_state',
BatteryState,
self.update_battery_label)
self.target_sub = rospy.Subscriber("/visual_tracker/target", Twist,
self.draw_target)
self.distance_error_sub = rospy.Subscriber(
"/visual_tracker/distance_error", Point,
self.update_distance_error)
self.image_sub = rospy.Subscriber('/camera/image_decompressed',
SensorImage,
self.image_subscriber_callback)
self.distance_sub = rospy.Subscriber('/laser_wall/wall_position',
Float32MultiArray,
self.update_distance_label)
# Publishers
self.gui_target_pub = rospy.Publisher('/visual_tracker/gui_target',
Point,
queue_size=1)
self.frame_pub = rospy.Publisher('/visual_tracker/frame_num',
UInt8,
queue_size=1)
self.control_status_msg = rospy.Publisher(
'/visual_tracker/target_tracking_msg', UInt8, queue_size=1)
rospy.init_node('gui_v2', anonymous=False)
rospy.Timer(rospy.Duration(1.0 / 30.0),
self.control_status_publish_callback)
rospy.loginfo("GUI initialised")
def save_pos(self, event):
## updating the position of the target point from position of mouse click on image
self.pos_x = event.x
self.pos_y = event.y
def get_target_distance(self, entry):
val = int(eval(self.e1.get()))
if (val < 1 or val > 5):
self.e1.delete(0, 10)
self.e1.insert("Invalid value")
else:
self.xTarget = val
def close_gui(self):
self.control_status = 0
msg = UInt8()
for i in range(1, 10):
msg.data = self.control_status
self.control_status_msg.publish(msg)
rospy.sleep(rospy.Duration(0.05))
self.master.quit()
def control_status_publish_callback(self, time_event):
self.flight_status_label.configure(
text="Autonomous mode: {}".format(self.control_status))
msg = UInt8()
msg.data = self.control_status
self.control_status_msg.publish(msg)
def start_autonomous(self):
if (self.control_status < 1 and self.circle_center[0] != None):
self.control_status = 1
rospy.loginfo("Autonomous tracking started")
else:
rospy.loginfo("No target selected")
def set_approach(self):
if (self.control_status > 0 and self.xTarget != 0):
self.control_status = 1 + self.xTarget
elif (self.xTarget == 0):
rospy.loginfo("Approach distance not set")
else:
rospy.loginfo("No target selected or autonomous control not set")
def image_subscriber_callback(self, image):
cv_image = CvBridge().imgmsg_to_cv2(image, "rgb8")
cv2.circle(cv_image, (640, 360), 1, (255, 0, 0), 10)
if self.circle_center[0] != None:
cv2.circle(
cv_image,
(int(self.circle_center[0]), int(self.circle_center[1])), 3,
self.circ_color, 10)
if self.bb_data[0] != None:
cv2.rectangle(cv_image, (self.bb_data[0], self.bb_data[1]),
(self.bb_data[0] + self.bb_data[2],
self.bb_data[1] + self.bb_data[3]),
self.circ_color, 2)
self.img = Image.fromarray(cv_image)
def draw_target(self, data):
self.circle_center = [data.linear.x, data.linear.y]
if data.linear.z:
self.circ_color = (0, 255, 0)
else:
self.circ_color = (255, 0, 0)
if data.angular.z:
self.bb_data = (int(data.linear.x - data.angular.x / 2),
int(data.linear.y - data.angular.y / 2),
int(data.angular.x), int(data.angular.y))
else:
self.bb_data = (None, None, None, None)
def update_image(self):
## Updating the image from the 'drone_cam_sub.py', if it's new. The update is automatic with a frequency 20 Hz (50 ms)
frequency = 30.0
try:
if self.img != self.prev_img:
self.imgtk = ImageTk.PhotoImage(self.img)
self.image_label.pic = self.imgtk
self.image_label.configure(image=self.imgtk)
self.prev_img = self.img
except:
print("Image not updated")
self.enable_video_stream = self.image_label.after(
int(1000 / frequency), self.update_image)
def select_target(self):
## Allows the user to select target, and interrupt selection if wanted
if not self.select_target_bool:
rospy.loginfo("User is selecting target")
self.select_target_bool = True
self.imgClick = True
self.select_target_button.configure(text="Cancel")
self.image_label.bind("<Button-1>", self.target_selected)
self.image_label.configure(cursor="dotbox")
else:
rospy.loginfo("User cancelled selection")
self.select_target_bool = False
self.imgClick = False
self.select_target_button.configure(text="Select target")
self.image_label.unbind("<Button-1>")
self.image_label.configure(cursor="")
def target_selected(self, event):
## Once target has been selected, variables and functions need to be reset.
## By un-commenting line 158 control will be disabled, once autonomous flight is enabled
## (For now it is possible to interfere with the drone by using the keyboard)
self.select_target_bool = False
rospy.loginfo("User selected target")
self.imgClick = False
self.save_pos(event)
self.publish_pos()
self.update_image()
self.select_target_button.configure(text="Select target")
self.image_label.unbind("<Button-1>")
self.image_label.configure(cursor="")
def update_distance_label(self, data):
self.x_distance_label.configure(
text='X Distance:\n{:02.2f} m'.format(data.data[4]))
self.yaw_distance_label.configure(
text='Yaw angle:\n{:02.2f} deg'.format(data.data[2]))
def update_distance_error(self, data):
# self.x_distance_label.configure( text = 'X Distance:\n{:02.2f} m'.format(data.x))
self.y_distance_label.configure(
text='Y Distance:\n{:02.2f} m'.format(data.y))
self.z_distance_label.configure(
text='Z Distance:\n{:02.2f} m'.format(data.z))
def update_battery_label(self, data):
self.battery_label.configure(
text='Battery level:\n{} %'.format(data.percentage))
def publish_pos(self):
#publishing the position of the target position in pixels
if not rospy.is_shutdown():
p = Point()
p.x = self.pos_x
p.y = self.pos_y
p.z = 0
self.gui_target_pub.publish(p)
rospy.loginfo("New Gui target published (%d, %d)", self.pos_x,
self.pos_y)
class LinkStack:
def __init__(self, master):
self.master = master
master.title("LinkStack")
self.stack = self.read_stack()
self.stack_size = len(self.stack)
self.pointer = 0
self.label = Label(master, text = 'Enter link: ')
self.label.pack(side = LEFT)
self.del_link = Button(master, text = 'Del', width = 4, command=self.delete)
self.del_link.pack(side = RIGHT)
self.paste_link = Button(master, text = 'Paste', width = 5, command=self.paste)
self.paste_link.pack(side = RIGHT)
self.copy_link = Button(master, text = 'Copy', width = 5, command=self.copy)
self.copy_link.pack(side = RIGHT)
self.pop_button = Button(master, text = 'Pop', width = 7, command=self.pop)
self.pop_button.pack(side = RIGHT)
self.push_button = Button(master, text = 'Push', width = 7, command=self.push)
self.push_button.pack(side = RIGHT)
self.link_input = Entry(master, width = 72)
self.link_input.pack(side = RIGHT)
def read_stack(self):
f = open('stack.txt', 'a+').close()
txt = open('stack.txt', 'rU').read()
lines = txt.splitlines()
line_list = [line for line in lines if line]
return line_list
def write_stack(self, stack):
txt = open('stack.txt', 'wb')
for line in stack:
txt.write('{}\r\n'.format(line))
def pop(self):
if len(self.stack):
line = self.stack[self.pointer].rstrip('\r\n')
self.link_input.delete(0, 'end')
self.link_input.insert(0, line)
self.pointer = (self.pointer + 1) % self.stack_size
def push(self):
line = self.link_input.get()
if line and not line in self.stack:
self.link_input.delete(0, 'end')
self.stack.insert(0, line)
self.stack_size = len(self.stack)
self.pointer = 0
self.write_stack(self.stack)
def copy(self):
line = self.link_input.get().rstrip('\r\n')
if line:
root.clipboard_clear()
root.clipboard_append(line)
def paste(self):
line = root.clipboard_get()
if line:
self.link_input.delete(0, 'end')
self.link_input.insert(0, line)
def delete(self):
line = self.link_input.get().rstrip('\r\n')
if line and line in self.stack:
self.link_input.delete(0, 'end')
self.stack.remove(line)
self.stack_size = len(self.stack)
self.pointer = 0
self.write_stack(self.stack)
class App:
def __init__(self, master):
self.master = master
column0_padx = 24
row_pady = 40
self.imgck = IntVar()
self.latck = IntVar()
self.lonck = IntVar()
self.timeck = IntVar()
self.dateck = IntVar()
self.datestate = int()
self.imgval = StringVar()
self.latval = StringVar()
self.lonval = StringVar()
self.timeval = StringVar()
self.dateval = StringVar()
self.headerVal = IntVar()
self.rbv = IntVar()
vcmd = (master.register(self.validate), '%d', '%i', '%P', '%s',
'%S', '%v', '%V', '%W')
self.entryExif = Entry(master, relief="sunken")
self.entryExif.insert(0, "EXIF csv file")
self.entryExif.grid(row=0,columnspan=4, sticky='EW',padx=5, pady=10)
exifbtn = Button(master, text="OPEN CSV file", command=self.getEXIFfile)
exifbtn.grid(row=1, column=0, padx=5, sticky='w')
##added to allow header line
self.headerOpt = Checkbutton(master, text="Select if CSV file has header line", variable=self.headerVal)
self.headerOpt.grid(row=2, column=0, padx=5, sticky='w')
self.entryJPGS = Entry(master, relief="sunken")
self.entryJPGS.insert(0, "JPEG folder")
self.entryJPGS.grid(row=3,columnspan=4, sticky='EW',padx=5, pady=10)
JPGbtn = Button(master, text="OPEN JPEG folder", command=self.getJPEGFolder)
JPGbtn.grid(row=4, column=0, padx=5, sticky='w')
self.paramFile = Entry(master, relief="sunken")
self.paramFile.insert(0, "Param file")
self.paramFile.grid(row=5, columnspan=4, sticky='EW', padx=5, pady=10)
parambtn = Button(master, text="OPEN PARAM file", command=self.getParamfile)
parambtn.grid(row=6, column=0, padx=5, sticky='w')
lbl_exiftag = Label(master, text="EXIF tag", wraplength=100,
anchor='w', justify='left')
lbl_column = Label(master, text="CSV column (zero based)", wraplength=100,
anchor='w', justify='left')
cbImage = Checkbutton(master, text='Image name', variable=self.imgck,
command=self.imgcheck)
cbLatitude = Checkbutton(master, text='Latitude', variable=self.latck,
command=self.latcheck)
cbLongitude = Checkbutton(master, text='Longitude', variable=self.lonck,
command=self.loncheck)
cbTime = Checkbutton(master, text='GPSTime', variable=self.timeck,
command=self.timecheck)
cbDate = Checkbutton(master, text='GPSDate', variable=self.dateck,
command=self.datecheck)
lblText =Label(master, text="Free text fields:")
lblArtist = Label(master, text="Artist:")
## lbl_analysis = Label(master, text="Analysis Library")
self.entryImage = Entry(master, validate = 'key', validatecommand = vcmd,
width=5, state='disabled')
self.entryLat = Entry(master, validate = 'key', validatecommand = vcmd,
width=5, state='disabled')
self.entryLon = Entry(master, validate = 'key', validatecommand = vcmd,
width=5, state='disabled')
self.entryTime = Entry(master, validate = 'key', validatecommand = vcmd,
width=5, state='disabled')
self.entryDate = Entry(master, validate = 'key', validatecommand = vcmd,
width=5, state='disabled')
self.entryArtist = Entry(master, width=40)
#lbl_testcase_exec.grid(row=0, column=2, padx=20, pady=12, sticky='w')
lbl_exiftag.grid(row=7, column=0, padx=20, pady=12, sticky='w')
lbl_column.grid(row=7, column=1, padx=10, pady=12, sticky='w')
cbImage.grid(row=8, column=0, padx=20, sticky='w')
cbLatitude.grid(row=9, column=0, padx=20, sticky='w')
cbLongitude.grid(row=10, column=0, padx=20, sticky='w')
cbTime.grid(row=11, column=0, padx=20, sticky='w')
cbDate.grid(row=12, column=0, padx=20, sticky='w')
lblText.grid(row=13, column=0, padx=30, sticky='w')
lblArtist.grid(row=14, column=0, padx=20, sticky='w')
self.entryImage.grid(row=8, column=1, padx=10, sticky='w')
self.entryLat.grid(row=9, column=1, padx=10, sticky='w')
self.entryLon.grid(row=10, column=1, padx=10, sticky='w')
self.entryTime.grid(row=11, column=1, padx=10, sticky='w')
self.entryDate.grid(row=12, column=1, padx=10, sticky='w')
lbl_datefmt = Label(master, text="Select date format:", wraplength=500,
anchor='w', justify='left')
lbl_datefmt.grid(row=12, column=1, padx=50, sticky='w')
self.entryArtist.grid(row=14, column=1, padx=10, sticky='w')
## ##added to allow header line
## self.dateOpt1 = Checkbutton(master, text="YYYYMMDD", variable=self.headerVal)
## self.dateOpt1.grid(row=10, column=1, padx=160, sticky='w')
## self.dateOpt2 = Checkbutton(master, text="YYYY:MM:DD", variable=self.headerVal)
## self.dateOpt2.grid(row=10, column=1, padx=260, sticky='w')
## self.dateOpt3 = Checkbutton(master, text="MM/DD/YYYY", variable=self.headerVal)
## self.dateOpt3.grid(row=10, column=1, padx=360, sticky='w')
#try radio buttons
Radiobutton(master, text="YYYYMMDD", variable=self.rbv, value=1, command=self.rdioInvoke).grid(row=11, column=1, padx=190, sticky='w')
Radiobutton(master, text="YYYY:MM:DD", variable=self.rbv, value=2).grid(row=12, column=1, padx=190, sticky='w')
Radiobutton(master, text="MM/DD/YYYY", variable=self.rbv, value=3).grid(row=13, column=1, padx=190, sticky='w')
# buttons
bottom_frame = Frame(master)
bottom_frame.grid(row=30, column=1, columnspan=3, sticky='w')
#I had to add the self to the prefix, otherwise my rdioInvoke wouldn't work.
#I'm guessing the self is sort of the global aspect.
#temporarily commenting this out so I can just test reading the param file
self.btn_start = Button(bottom_frame, text = "Submit", width=7, command=self.MergeExif)
#self.btn_start = Button(bottom_frame, text = "Submit", width=7, command=self.readParamfile)
self.btn_start.pack(side='left', pady=20)
self.btn_start.config(state='disabled')
## btn_commit = Button(bottom_frame, text="Commit", width=7)
## btn_commit.pack(side='left', padx=80)
btn_exit = Button(bottom_frame, text="Exit", width=7, command=self.cbtnClick)
btn_exit.pack(side='left', padx=10)
def rdioInvoke(self):
print "rdioInvoke"
self.btn_start.configure(state='normal')
def cbtnClick(self):
print "close button event handler"
self.master.destroy()
def imgcheck(self):
print "check"
if self.imgck.get() == 0:
self.entryImage.configure(state='disabled')
else:
self.entryImage.configure(state='normal')
def latcheck(self):
print "check"
if self.latck.get() == 0:
self.entryLat.configure(state='disabled')
else:
self.entryLat.configure(state='normal')
def loncheck(self):
print "check"
if self.lonck.get() == 0:
self.entryLon.configure(state='disabled')
else:
self.entryLon.configure(state='normal')
def timecheck(self):
print "check"
if self.timeck.get() == 0:
self.entryTime.configure(state='disabled')
else:
self.entryTime.configure(state='normal')
def datecheck(self):
print "check"
if self.dateck.get() == 0:
self.entryDate.configure(state='disabled')
else:
self.entryDate.configure(state='normal')
#self.datestate == 1
def validate(self, action, index, value_if_allowed,
prior_value, text, validation_type, trigger_type, widget_name):
if text in '0123456789':
return True
else:
return False
def getEXIFfile(self):
EXIFcsvfile = tkFileDialog.askopenfilename(title='Image EXIF CSV file')
#need to fix the next line
self.entryExif.delete(0,END)
if len(EXIFcsvfile) > 0:
self.entryExif.insert(0,EXIFcsvfile)
def getJPEGFolder(self):
#by not specifying an intial directory, it starts where the script is located.
JPGfolder = tkFileDialog.askdirectory(title='Pick JPEG folder')
#need to clear anything that's there
self.entryJPGS.delete(0,END)
if len(JPGfolder) > 0:
#print "now read JPEG folder %s" % JPGfolder
#for entry widget
self.entryJPGS.insert(0,JPGfolder)
def getParamfile(self):
PARAMtxtfile = tkFileDialog.askopenfilename(title='Paramter text file')
self.paramFile.delete(0,END)
if len(PARAMtxtfile) > 0:
self.paramFile.insert(0,PARAMtxtfile)
def readParamfile(self):
params = self.paramFile.get()
inputparams = open(params, "r")
allparams = inputparams.read()
for cmd3 in allparams.splitlines():
if "-comment" in cmd3:
## print cmd3
## print " "
val3 = cmd3
for cmd4 in allparams.splitlines():
if "-sep" in cmd4:
## print cmd4
## print " "
#return cmd4
val4 = cmd4
for cmd6 in allparams.splitlines():
if "-Caption=" in cmd6:
## print cmd6
## print " "
#return cmd6
val6=cmd6
for cmd9 in allparams.splitlines():
if "-Caption-Abstract" in cmd9:
## print cmd9
## print " "
#return cmd9
val9 = cmd9
for cmd10 in allparams.splitlines():
if "-ImageDescription=" in cmd10:
## print cmd10
## print " "
#return cmd10
val10 = cmd10
## print "read params"
## print "val3"
## print val3
return (val3, val4, val6, val9, val10)
#self.MergeExif()
def MergeExif(self):
try:
test = self.entryExif.get()
print test
## print "date format"
## print str(self.rbv.get())
inputfile = open(test, "r")
#print "made it here 1"
imgval = int(self.entryImage.get())
#print self.entryImage.get()
#print str(imgval)
if self.latck.get() <> 0:
latval = int(self.entryLat.get())
#print "made it here 1a"
if self.lonck.get() <> 0:
lonval = int(self.entryLon.get())
print "made it here 1b"
if self.timeck.get() <> 0:
timeval = int(self.entryTime.get())
print "made it here 1c"
if self.dateck.get() <> 0:
dateval = int(self.entryDate.get())
print "got date"
print str(dateval)
print "made it here 2"
##add this if statement to deal with header value
if self.headerVal.get() == 1:
print "have a header value"
line = inputfile.readline()
else:
print "no header value"
print "getting return"
## retcmd3, retcmd4, retcmd6, retcmd9, retcmd10 = self.readParamfile()
## print "just cmd3"
## print retcmd3
allreturns = self.readParamfile()
print "allreturns"
print allreturns
## print "first return"
## print allreturns[0]
while 1:
line = inputfile.readline()
print "made it here 3"
values = str.split(line,",")
## print line
## print "imgval"
## print imgval
##if extension is included in text file
img = values[imgval].strip()
##if extension is NOT included in text file
##img = values[imgval].strip() + '.JPG'
vlat = values[latval].strip()
vlon = values[lonval].strip()
ingpsdate = values[dateval].strip()
## #section to read date formats
if self.rbv.get()==1:
vyr=str(ingpsdate)[0:4]
vmm=str(ingpsdate)[4:6]
vdd=str(ingpsdate)[6:8]
vgpsdate=vyr+":"+vmm+":"+vdd
if self.rbv.get()==2:
vgpsdate=ingpsdate
if self.rbv.get()==3:
vmm, vdd, vyr = ingpsdate.split("/")
if len(vmm)==1:
vmm="0"+vmm
if len(vdd)==1:
vdd="0"+vdd
vgpsdate=vyr+":"+vmm+":"+vdd
## if ingpsdate.find(':')==-1:
## vyr=str(ingpsdate)[0:4]
## vmm=str(ingpsdate)[4:6]
#### print ingpsdate
#### print "year"
#### print vyr
#### print "month"
#### print vmm
## vdd=ingpsdate[6:8]
## vgpsdate=vyr+":"+vmm+":"+vdd
## else:
## vgpsdate=ingpsdate
print vgpsdate
vgpstime = values[timeval].strip()
imagefolder = self.entryJPGS.get()
fullimg = os.path.join(imagefolder, img)
fullimg = fullimg.replace('\\','/')
vartist = self.entryArtist.get()
vartistquotes = '"'+vartist+'"'
## print str(fullimg)
## print str(vlat)
## print str(vlon)
## print str(vgpsdate)
## print str(vgpstime)
if (float(vlat)) > 0:
print "latref1"
vlatref = 'N'
else:
print "latref2"
vlatref = 'S'
if (float(vlon)) > 0:
vlonref = 'E'
else:
vlonref = 'W'
## print str(vlatref)
## print str(vlonref)
cmd = "exiftool -GPSDateStamp=" + vgpsdate + " -GPSTimeStamp="+vgpstime+" -GPSLatitude="+vlat+" -GPSLatitudeRef="+ vlatref+\
" -GPSLongitude="+vlon+" -GPSLongitudeRef="+vlonref+" "+ " -Artist=" +vartistquotes +" "+fullimg
print cmd
#print "made it past first os.system"
subprocess.check_call(cmd, shell=True)
print "executed"
cmd2 = """exiftool -Credit="U.S. Geological Survey" -Contact="[email protected] " """+ fullimg
subprocess.check_call(cmd2, shell=True)
#jpeg comment
print "in command 3 section"
cmd3=allreturns[0]
cmd3new = cmd3+" "+fullimg
print cmd3new
#print cmd3
#cmd3 = """exiftool -comment="Photo from down-looking camera on the USGS SEABOSS deployed from the R/V Rafael during survey 2012-003-FA (http://woodshole.er.usgs.gov/operations/ia/public_ds_info.php?fa=2012-003-FA). Released as part of publication DOI:10.3133/ds937. " """+ fullimg
subprocess.check_call(cmd3new, shell=True)
#iptc info
#cmd4 = """exiftool -sep ", " -keywords="Barnegat Bay, New Jersey, 2012-003-FA, SEABOSS, sea floor, USGS " """+ fullimg
cmd4=allreturns[1]
cmd4new = cmd4+" "+fullimg
#subprocess.check_call(cmd4, shell=True)
subprocess.check_call(cmd4new, shell=True)
#cmd5 unused and skipped
#xmp info
#cmd6 = """exiftool -Caption="Photograph of the sea floor in Barnegat Bay, New Jersey from survey 2012-003-FA " """+ fullimg
cmd6=allreturns[2]
cmd6new = cmd6+" "+fullimg
#subprocess.check_call(cmd6, shell=True)
subprocess.check_call(cmd6new, shell=True)
print "did caption"
#EXIF info
cmd7 = """exiftool -Copyright="Public Domain - please credit U.S. Geological Survey " """ + fullimg
subprocess.check_call(cmd7, shell=True)
print "did copyright"
#iptc info
cmd8 = """exiftool -CopyrightNotice="Public Domain - please credit U.S. Geological Survey " """ + fullimg
subprocess.check_call(cmd8, shell=True)
#iptc info
#cmd9 = """exiftool -Caption-Abstract="Photograph of the sea floor in Barnegat Bay, New Jersey from survey 2012-003-FA " """+ fullimg
cmd9=allreturns[3]
cmd9new = cmd9+" "+fullimg
#subprocess.check_call(cmd9, shell=True)
subprocess.check_call(cmd9new, shell=True)
#exif info - software such as Picasso use this as the caption
#cmd10 = """exiftool -ImageDescription="Photograph of the sea floor in Barnegat Bay, New Jersey from survey 2012-003-FA " """+ fullimg
cmd10=allreturns[4]
cmd10new = cmd10+" "+fullimg
#subprocess.check_call(cmd10, shell=True)
subprocess.check_call(cmd10new, shell=True)
except:
print "booboo maybe?"
inputfile.close()
print "done"
class EMNN():
def __init__(self, conn):
conn.gui = True
queue = self.queue = Queue.Queue()
conn.queue = queue
self.conn = conn
def startgui(self):
self.root = root = Tk()
root.title('SIMAPSE - Simulation Maps for Ecological Niche Modelling')
root.geometry('695x445+375+115')
root.tk.call('encoding', 'system', 'utf-8')
root.configure(bg='#d9d9d9')
root.resizable(width='false', height='false')
self.gui()
self.root.after(100, self.periodicUpdate)
root.mainloop()
def gui(self):
from Tkinter import Button, Entry, Frame, Label, Checkbutton, \
Scrollbar, Text, IntVar, StringVar, OptionMenu
self.dir_project = ''
self.folds = 0
self.func = ""
self.aucfilter = IntVar()
self.lightgray = '#d9d9d9'
self.darkgray = '#d3d3d3'
self.normaltext = ("Helvetica", -10)
self.boldtext = ("Helvetica", -10, "bold")
self.bigtext = ("Helvetica", -12, "bold")
self.smalltext = ("Helvetica", -9)
self.butData = Button(self.root)
self.butData.place(in_=self.root, x=5, y=5)
self.butData.configure(height=1,
width=10,
text="Data File",
font=self.normaltext,
highlightbackground=self.lightgray,
command=self.dataOpen)
self.butRasterFolder = Button(self.root)
self.butRasterFolder.place(in_=self.root, x=5, y=35)
self.butRasterFolder.configure(height=1,
width=10,
text="Raster Folder",
font=self.normaltext,
highlightbackground=self.lightgray,
command=self.rasterOpen)
self.butOutFolder = Button(self.root)
self.butOutFolder.place(in_=self.root, x=5, y=65)
self.butOutFolder.configure(height=1,
width=10,
text="Out Folder",
font=self.normaltext,
highlightbackground=self.lightgray,
command=self.outOpen)
self.entData = Entry(self.root)
self.entData.place(in_=self.root, x=100, y=9)
self.entData.configure(textvariable="file_data",
font=self.normaltext,
width=97,
background=self.darkgray,
relief="flat",
highlightbackground=self.lightgray)
self.entData.insert(0, '')
self.entOutFolder = Entry(self.root)
self.entOutFolder.place(in_=self.root, x=100, y=69)
self.entOutFolder.configure(textvariable="out_dir",
font=self.normaltext,
width=97,
background=self.darkgray,
relief="flat",
highlightbackground=self.lightgray)
self.entOutFolder.insert(0, '')
self.entRasterFolder = Entry(self.root)
self.entRasterFolder.place(in_=self.root, x=100, y=39)
self.entRasterFolder.configure(textvariable="dir_rasters",
font=self.normaltext,
width=97,
background=self.darkgray,
relief="flat",
highlightbackground=self.lightgray)
self.entRasterFolder.insert(0, '')
self.activeMethod = StringVar(self.root)
self.activeMethod.set("Random repetition")
self.butMETHOD = OptionMenu(
self.root,
self.activeMethod,
"Random repetition",
"Cross validation",
"Bootstrapping",
command=lambda x: self.displayMethodFrame(x))
self.butMETHOD.place(in_=self.root,
x=4,
y=97,
height="25",
width="120")
self.butMETHOD.configure(font=self.smalltext,
background=self.lightgray)
self.displayMethodFrame(self.activeMethod.get())
self.activeOption = StringVar(self.root)
self.activeOption.set("Network structure")
self.butOPTION = OptionMenu(
self.root,
self.activeOption,
"Network structure",
"Options",
command=lambda x: self.displayOptionFrame(x))
self.butOPTION.place(in_=self.root,
x=4,
y=182,
height="25",
width="120")
self.butOPTION.configure(font=self.smalltext,
background=self.lightgray)
self.displayOptionFrame(self.activeOption.get())
self.Progress_frame = Frame(self.root)
self.Progress_frame.place(in_=self.root, x=5, y=423)
self.Progress_frame.configure(borderwidth="2",
relief='sunken',
height="20",
width="105",
bg='white')
self.Progress_bar = Label(self.Progress_frame)
self.Progress_bar.place(x=0, y=0)
self.Progress_bar.configure(font=self.smalltext)
self.Progress_info = Label(self.root)
self.Progress_info.place(x=110, y=425)
self.Progress_info.configure(font=self.smalltext, bg=self.lightgray)
self.frameButtons = Frame(self.root)
self.frameButtons.place(in_=self.root, x=5, y=336)
self.frameButtons.configure(borderwidth="2",
bg=self.lightgray,
relief="raise",
height="84",
width="260")
self.butREAD = Button(self.root)
self.butREAD.place(in_=self.frameButtons, x=5, y=5, width=70)
self.butREAD.configure(font=self.bigtext,
highlightbackground=self.lightgray,
text="READ",
command=self.read)
self.butRUN = Button(self.root)
self.butRUN.place(in_=self.frameButtons, x=80, y=5, width=70)
self.butRUN.configure(font=self.bigtext,
highlightbackground=self.lightgray,
text="RUN",
command=self.returnVar,
state='disabled')
self.butRESULTS = Button(self.root)
self.butRESULTS.place(in_=self.frameButtons, x=155, y=5, width=80)
self.butRESULTS.configure(font=self.bigtext,
highlightbackground=self.lightgray,
text="RESULTS",
command=self.returnResults,
state='disabled')
self.butPROJECT = Button(self.root)
self.butPROJECT.place(in_=self.frameButtons, x=5, y=45, width=70)
self.butPROJECT.configure(font=self.boldtext,
highlightbackground=self.lightgray,
text="PROJECT",
command=self.project,
state='disabled')
self.frameText = Frame(self.root)
self.frameText.place(in_=self.root, x=270, y=100)
self.frameText.configure(height=320, width=400)
self.scrollbar = Scrollbar(self.root)
self.textFrame = Text(self.frameText, wrap='word')
self.textFrame.configure(font=self.normaltext, height="24", width="65")
self.textFrame.place(x=0, y=0)
self.textFrame.configure(yscrollcommand=self.scrollbar.set)
self.scrollbar.configure(command=self.textFrame.yview,
highlightbackground=self.lightgray)
self.scrollbar.place(x=675, y=100, height=320)
def displayMethodFrame(self, method):
''' Displays individual frames for the subsetting method'''
from Tkinter import Button, Entry, Frame, Label
if self.__dict__.has_key('frameMethodSelection'):
self.frameMethodSelection.destroy()
self.varupdate()
c = self.conn.simargs
self.frameMethodSelection = Frame(self.root)
self.frameMethodSelection.place(in_=self.root, x=5, y=122)
self.frameMethodSelection.configure(borderwidth="2",
relief="raise",
height="60",
width="260",
bg=self.lightgray)
if method == "Random repetition":
self.labRepetitions = Label(self.root)
self.labRepetitions.place(in_=self.frameMethodSelection, x=2, y=10)
self.labRepetitions.configure(font=self.normaltext,
borderwidth="1",
justify='left',
anchor='e',
bg=self.lightgray,
text="Number of repetitions:")
self.entRepetitions = Entry(self.root)
self.entRepetitions.place(in_=self.frameMethodSelection,
x=125,
y=10)
self.entRepetitions.configure(textvariable="repetitions",
width="7",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entRepetitions.delete(0, 'end')
self.entRepetitions.insert('end', c['repetitions'])
elif method == "Cross validation":
self.labRepetitions = Label(self.root)
self.labRepetitions.place(in_=self.frameMethodSelection, x=2, y=10)
self.labRepetitions.configure(font=self.normaltext,
bg=self.lightgray,
text="Number of folds:")
self.entRepetitions = Entry(self.root)
self.entRepetitions.place(in_=self.frameMethodSelection,
x=100,
y=10)
self.entRepetitions.configure(textvariable="repetitions",
width="7",
highlightbackground=self.lightgray,
font=self.normaltext)
self.entRepetitions.delete(0, 'end')
self.entRepetitions.insert('end', c['repetitions'])
elif method == "Bootstrapping":
self.labRepetition = Label(self.root)
self.labRepetition.place(in_=self.frameMethodSelection, x=2, y=5)
self.labRepetition.configure(borderwidth="1",
text="Number of Bootstraps:",
bg=self.lightgray,
font=self.normaltext)
self.entRepetitions = Entry(self.root)
self.entRepetitions.place(in_=self.frameMethodSelection,
x=125,
y=5)
self.entRepetitions.configure(textvariable="repetitions",
width="7",
highlightbackground=self.lightgray,
font=self.normaltext)
self.entRepetitions.delete(0, 'end')
self.entRepetitions.insert('end', c['repetitions'])
self.labBsize = Label(self.root)
self.labBsize.place(in_=self.frameMethodSelection, x=2, y=30)
self.labBsize.configure(borderwidth="1",
text="Bootstraps Sample Size:",
bg=self.lightgray,
font=self.normaltext)
self.entBsize = Entry(self.root)
self.entBsize.place(in_=self.frameMethodSelection, x=125, y=30)
self.entBsize.configure(textvariable="Bsize",
width="7",
highlightbackground=self.lightgray,
font=self.normaltext)
self.entBsize.delete(0, 'end')
self.entBsize.insert('end', c['bsize'])
def displayOptionFrame(self, option):
''' Displays individual frames for the subsetting method'''
from Tkinter import Button, Entry, Frame, Label, Checkbutton
if self.__dict__.has_key('frameOptionSelection'):
self.frameOptionSelection.destroy()
self.varupdate()
c = self.conn.simargs
self.frameOptionSelection = Frame(self.root)
self.frameOptionSelection.place(in_=self.root, x=5, y=207)
self.frameOptionSelection.configure(borderwidth="2",
relief="raise",
height="125",
width="260",
bg=self.lightgray)
if option == "Network structure":
self.labMaxiter = Label(self.root)
self.labMaxiter.place(in_=self.frameOptionSelection, x=190, y=5)
self.labMaxiter.configure(borderwidth="1",
font=self.normaltext,
text="Internal",
bg=self.lightgray)
self.labNNN = Label(self.root)
self.labNNN.place(in_=self.frameOptionSelection, x=95, y=5)
self.labNNN.configure(borderwidth="1",
font=self.normaltext,
text="Reported",
bg=self.lightgray)
self.labTI = Label(self.root)
self.labTI.place(in_=self.frameOptionSelection, x=5, y=25)
self.labTI.configure(borderwidth="1",
font=self.normaltext,
text="Total iterations =",
bg=self.lightgray)
self.entITERReport = Entry(self.root)
self.entITERReport.place(in_=self.frameOptionSelection, x=88, y=25)
self.entITERReport.configure(textvariable="AUCReport",
width="10",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entITERReport.delete(0, 'end')
self.entITERReport.insert('end', c['iterreport'])
self.times = Label(self.root)
self.times.place(in_=self.frameOptionSelection, x=160, y=25)
self.times.configure(text="x",
font=self.normaltext,
bg=self.lightgray)
self.entITERInter = Entry(self.root)
self.entITERInter.place(in_=self.frameOptionSelection, x=180, y=25)
self.entITERInter.configure(textvariable="maxiter",
width="10",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entITERInter.delete(0, 'end')
self.entITERInter.insert('end', c['iterinter'])
self.labEta = Label(self.root)
self.labEta.place(in_=self.frameOptionSelection, x=5, y=55)
self.labEta.configure(borderwidth="1",
font=self.normaltext,
text="Learning Rate",
bg=self.lightgray)
self.butHINT = Button(self.root)
self.butHINT.place(in_=self.frameOptionSelection,
x=65,
y=75,
height=23,
width=20)
self.butHINT.configure(font=self.smalltext,
text="H",
command=self.hint,
state='disabled',
highlightbackground=self.lightgray)
self.labMomentum = Label(self.root)
self.labMomentum.place(in_=self.frameOptionSelection, x=88, y=55)
self.labMomentum.configure(borderwidth="1",
font=self.normaltext,
text="Momentum",
bg=self.lightgray)
self.entLRATE = Entry(self.root)
self.entLRATE.place(in_=self.frameOptionSelection, x=5, y=75)
self.entLRATE.configure(textvariable="eta",
width="8",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entLRATE.delete(0, 'end')
self.entLRATE.insert('end', c['lrate'])
self.entMomentum = Entry(self.root)
self.entMomentum.place(in_=self.frameOptionSelection, x=90, y=75)
self.entMomentum.configure(textvariable="momentum",
width="8",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entMomentum.delete(0, 'end')
self.entMomentum.insert('end', c['momentum'])
self.labNNS = Label(self.root)
self.labNNS.place(in_=self.frameOptionSelection, x=165, y=55)
self.labNNS.configure(borderwidth="1",
font=self.normaltext,
text="Hidden Layers",
bg=self.lightgray)
self.entNNShape = Entry(self.root)
self.entNNShape.place(in_=self.frameOptionSelection, x=160, y=75)
self.entNNShape.configure(textvariable="HiddenLyr",
width="14",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entNNShape.delete(0, 'end')
self.entNNShape.insert('end', c['hiddenlyrs'])
elif option == "Options":
self.labPercentage = Label(self.root)
self.labPercentage.place(in_=self.frameOptionSelection, x=2, y=5)
self.labPercentage.configure(borderwidth="1",
text="Test %:",
font=self.normaltext,
bg=self.lightgray)
self.entPercentage = Entry(self.root)
self.entPercentage.place(in_=self.frameOptionSelection,
x=45,
y=5,
width=30)
self.entPercentage.configure(textvariable="Percentage",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entPercentage.delete(0, 'end')
self.entPercentage.insert('end', c['percentage'])
self.labAPRatio = Label(self.root)
self.labAPRatio.place(in_=self.frameOptionSelection, x=80, y=5)
self.labAPRatio.configure(borderwidth="1",
text="Pseudoabsences/Presences:",
font=self.normaltext,
bg=self.lightgray)
self.entAPRatio = Entry(self.root)
self.entAPRatio.place(in_=self.frameOptionSelection, x=220, y=5)
self.entAPRatio.configure(textvariable="apratio",
width="4",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entAPRatio.delete(0, 'end')
self.entAPRatio.insert('end', c['apratio'])
self.labBurnin = Label(self.root)
self.labBurnin.place(in_=self.frameOptionSelection, x=2, y=30)
self.labBurnin.configure(borderwidth="1",
text="Burn-in iterations:",
font=self.normaltext,
bg=self.lightgray)
self.entBurnin = Entry(self.root)
self.entBurnin.place(in_=self.frameOptionSelection, x=90, y=30)
self.entBurnin.configure(textvariable="burnin",
width="8",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entBurnin.delete(0, 'end')
self.entBurnin.insert('end', c['burnin'])
self.chkAucFilter = Checkbutton(self.root)
self.chkAucFilter.place(in_=self.frameOptionSelection, x=2, y=60)
self.chkAucFilter.configure(font=self.normaltext,
text="Filter with AUC threshold",
variable=self.aucfilter,
bg=self.lightgray,
command=self.aucstate)
self.labAUCTrain = Label(self.root)
self.labAUCTrain.place(in_=self.frameOptionSelection, x=5, y=85)
self.labAUCTrain.configure(borderwidth="1",
font=self.normaltext,
text="training data",
bg=self.lightgray)
self.entAUCTrain = Entry(self.root)
self.entAUCTrain.place(in_=self.frameOptionSelection, x=70, y=85)
self.entAUCTrain.configure(textvariable="valueAuc",
width="8",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entAUCTrain.delete(0, 'end')
self.entAUCTrain.insert('end', c['auctrain'])
self.labAUCTest = Label(self.root)
self.labAUCTest.place(in_=self.frameOptionSelection, x=130, y=85)
self.labAUCTest.configure(borderwidth="1",
font=self.normaltext,
text="testing data",
bg=self.lightgray)
self.entAUCTest = Entry(self.root)
self.entAUCTest.place(in_=self.frameOptionSelection, x=195, y=85)
self.entAUCTest.configure(textvariable="valueAucTest",
width="8",
font=self.normaltext,
highlightbackground=self.lightgray)
self.entAUCTest.delete(0, 'end')
self.entAUCTest.insert('end', c['auctest'])
self.aucstate()
def varupdate(self):
extract = self.extract
c = self.conn.simargs
c['file_data'] = extract('entData', c['file_data'])
c['dir_rasters'] = extract('entRasterFolder', c['dir_rasters'])
c['out_dir'] = extract('entOutFolder', c['out_dir'])
c['method'] = extract('activeMethod', c['method'])
c['iterreport'] = int(extract('entITERReport', c['iterreport']))
c['iterinter'] = int(extract('entITERInter', c['iterinter']))
c['lrate'] = float(extract('entLRATE', c['lrate']))
c['momentum'] = float(extract('entMomentum', c['momentum']))
c['hiddenlyrs'] = extract('entNNShape', c['hiddenlyrs'])
c['apratio'] = float(extract('entAPRatio', c['apratio']))
c['percentage'] = int(extract('entPercentage', c['percentage']))
c['burnin'] = int(extract('entBurnin', c['burnin']))
c['auctrain'] = float(extract('entAUCTrain', c['auctrain']))
c['auctest'] = float(extract('entAUCTest', c['auctest']))
c['repetitions'] = int(extract('entRepetitions', c['repetitions']))
c['bsize'] = int(extract('entBsize', c['bsize']))
c['aucfilter'] = bool(extract('aucfilter', int(c['aucfilter'])))
def extract(self, test, default):
if test in self.__dict__.keys():
value = self.__dict__[test].get()
else:
value = default
return value
def read(self):
import time
self.varupdate()
self.conn.processor(self.conn.manager.read_all, 'read')
def returnVar(self):
# Updates variables
self.varupdate()
self.conn.processor(self.conn.manager.model, 'run')
def returnResults(self):
self.varupdate()
self.conn.processor(self.conn.manager.results, 'results')
def project(self):
self.varupdate()
project_dir = askdirectory()
self.conn.simargs['project_dir'] = project_dir
self.conn.processor(self.conn.manager.project, 'project')
def hint(self):
self.varupdate()
self.conn.processor(self.conn.manager.hint, 'hint')
def dataOpen(self):
self.entData.delete(0, 'end')
file_data = askopenfilename(filetypes=[("text files",
"*.txt"), ("allfiles", "*")])
self.entData.insert('end', file_data)
def rasterOpen(self):
self.entRasterFolder.delete(0, 'end')
dir_rasters = askdirectory()
self.entRasterFolder.insert('end', dir_rasters)
def outOpen(self):
self.entOutFolder.delete(0, 'end')
out_dir = askdirectory()
self.entOutFolder.insert('end', out_dir)
def update_text(self, string_txt):
txt = string_txt + " \n"
self.textFrame.insert('end', txt)
self.textFrame.yview('end')
def processGraph(self, graph_object):
'''Just a wraper to call the graphics creation object'''
graph_object()
def periodicUpdate(self):
"""Executes periodic checks to GUI:
- if there are new messages and displays when true"""
try:
while 1:
code, args, kwargs = self.queue.get_nowait()
if code == Connector.CODE_TEXT:
self.update_text(*args)
elif code == Connector.CODE_PROGRESS:
self.progress(*args, **kwargs)
elif code == Connector.CODE_MODIFY_BUTTON:
self.modify_but(*args)
elif code == Connector.CODE_SHOWRESULTS:
self.showResults(*args)
elif code == Connector.CODE_GRAPHS:
self.processGraph(args)
else:
self.update_text('Unknown message...')
self.queue.task_done()
self.root.update()
except Queue.Empty:
pass
self.root.after(100, self.periodicUpdate)
def modify_but(self, state, buttonlist):
if buttonlist == 'all':
buttonlist = [
'READ', 'RUN', 'RESULTS', 'PROJECT', 'HINT', 'METHOD', 'OPTION'
]
for button in buttonlist:
but = "self.but%s.configure(state=\'%s\')" % (button, state)
exec(but)
def abundance(self):
self.entAUCTrain.configure(state='disabled')
self.entAUCTest.configure(state='disabled')
def aucstate(self):
if self.aucfilter.get(): state = 'normal'
else: state = 'disabled'
self.entAUCTrain.configure(state=state)
self.entAUCTest.configure(state=state)
def progress(self, value, maxvalue, **kwargs):
'''Shows the progress bar in GUI
args are:
Value - Value of the current progress
MaxValue - Value where progress terminates
kwargs are
color - Color for the progess bar
msg - message to display'''
color = 'blue'
if 'color' in kwargs: color = kwargs['color']
percent = (value * 100) / maxvalue
self.Progress_bar.configure(font=self.smalltext,
foreground="white",
background=color) #"#0000ff"
if percent <> 100:
width = int((percent / 100.000) * 20)
text = '%s%%' % percent
self.Progress_bar.configure(text=text, width=width)
if 'msg' in kwargs:
self.Progress_info.configure(text=kwargs['msg'])
elif percent == 100:
self.Progress_bar.configure(text="",
width=0,
relief="flat",
background="#ece9d8")
self.Progress_info.configure(text="")
def showResults(self, figures):
from Tkinter import Button
figures = [self.entOutFolder.get() + "/" + x for x in figures]
ResultsWindow = mytoplevel(self.root, figures, self)
ResultsWindow.title('Results')
butRW = Button(ResultsWindow,
text='CLOSE',
command=ResultsWindow.destroy)
butRW.pack()
def update_queue(self):
try:
while self.queue.qsize():
msg = '%s\n' % self.queue.get(0)
self.textFrame.insert('end', msg)
self.textFrame.yview('end')
except Queue.Empty:
pass
class AVA:
def __init__(self, master):
self.master = master
master.title("PWMAVA")
frame = Frame(master)
frame.grid(row=0, column=0)
#current status
self.time_label = Label(frame)
self.temp_label = Label(frame)
self.elapsed_label = Label(frame)
#current pwm values
self.white_pwm = 0
self.blue_pwm = 0
self.red_pwm = 0
self.uv_pwm = 0
self.ir_pwm = 0
self.entered_pwm = 0
self.white_pwm_label_text = IntVar()
self.white_pwm_label_text.set(self.white_pwm)
self.blue_pwm_label_text = IntVar()
self.blue_pwm_label_text.set(self.blue_pwm)
self.red_pwm_label_text = IntVar()
self.red_pwm_label_text.set(self.red_pwm)
self.uv_pwm_label_text = IntVar()
self.uv_pwm_label_text.set(self.uv_pwm)
self.ir_pwm_label_text = IntVar()
self.ir_pwm_label_text.set(self.ir_pwm)
#adjustable pwm labels
self.white_pwm_label = Label(master,
textvariable=self.white_pwm_label_text)
self.blue_pwm_label = Label(master,
textvariable=self.blue_pwm_label_text)
self.red_pwm_label = Label(master,
textvariable=self.red_pwm_label_text)
self.uv_pwm_label = Label(master, textvariable=self.uv_pwm_label_text)
self.ir_pwm_label = Label(master, textvariable=self.ir_pwm_label_text)
#static labels
self.white_label = Label(master, text="Current White PWM:")
self.blue_label = Label(master, text="Current Blue PWM:")
self.red_label = Label(master, text="Current Red PWM:")
self.uv_label = Label(master, text="Current UV PWM:")
self.ir_label = Label(master, text="Current IR PWM:")
#validation
vcmd = master.register(self.validate)
self.entry = Entry(master,
validate="key",
validatecommand=(vcmd, '%P'))
#buttons
self.enter_white_button = Button(master,
text="Enter White PWM",
command=lambda: self.update("white"))
self.enter_blue_button = Button(master,
text="Enter Blue PWM",
command=lambda: self.update("blue"))
self.enter_red_button = Button(master,
text="Enter Red PWM",
command=lambda: self.update("red"))
self.enter_uv_button = Button(master,
text="Enter UV PWM",
command=lambda: self.update("uv"))
self.enter_ir_button = Button(master,
text="Enter IR PWM",
command=lambda: self.update("ir"))
self.reset_button = Button(master,
text="Turn Off All",
command=lambda: self.update("reset"))
#layouts
self.time_label.grid(row=0, column=0)
self.elapsed_label.grid(row=0, column=1)
self.temp_label.grid(row=0, column=2)
self.white_label.grid(row=1, column=0, sticky=W)
self.blue_label.grid(row=2, column=0, sticky=W)
self.red_label.grid(row=3, column=0, sticky=W)
self.uv_label.grid(row=4, column=0, sticky=W)
self.ir_label.grid(row=5, column=0, sticky=W)
self.white_pwm_label.grid(row=1, column=1, columnspan=1, sticky=E)
self.blue_pwm_label.grid(row=2, column=1, columnspan=1, sticky=E)
self.red_pwm_label.grid(row=3, column=1, columnspan=1, sticky=E)
self.uv_pwm_label.grid(row=4, column=1, columnspan=1, sticky=E)
self.ir_pwm_label.grid(row=5, column=1, columnspan=1, sticky=E)
self.entry.grid(row=6, column=0, columnspan=3,
sticky=W + E) #entry bar
self.enter_white_button.grid(row=7, column=0, sticky=W + E)
self.enter_blue_button.grid(row=8, column=0, sticky=W + E)
self.enter_red_button.grid(row=9, column=0, sticky=W + E)
self.enter_uv_button.grid(row=10, column=0, sticky=W + E)
self.enter_ir_button.grid(row=11, column=0, sticky=W + E)
self.reset_button.grid(row=12, column=0, sticky=W + E)
self.timer_interval = 500 #500ms
self.log_count = 2 #take log every second
with open("LoggingData/log" + start_time.strftime("%m%d%Y-%H%M%S") +
".csv",
mode="w") as log_file:
ava_writer = csv.writer(log_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
ava_writer.writerow([
"Date", "Time", "Temperature", "WHITEPWM", "BLUEPWM", "REDPWM",
"UVPWM", "IRPWM"
])
self.stat_update()
def validate(self, new_text):
if not new_text:
self.entered_pwm = 0
return True
try:
if int(new_text) < 0:
return False
if int(new_text) > 100:
return False
self.entered_pwm = int(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "white":
self.white_pwm = self.entered_pwm
print("Pwm will now change for white!")
if method == "blue":
self.blue_pwm = self.entered_pwm
print("Pwm will now change for blue!")
if method == "red":
self.red_pwm = self.entered_pwm
print("Pwm will now change for red!")
if method == "uv":
self.uv_pwm = self.entered_pwm
print("Pwm will now change for uv!")
if method == "ir":
self.ir_pwm = self.entered_pwm
print("Pwm will now change for ir!")
elif method == "reset":
self.blue_pwm = self.entered_pwm
self.white_pwm = self.entered_pwm
self.red_pwm = self.entered_pwm
self.uv_pwm = self.entered_pwm
self.ir_pwm = self.entered_pwm
print("Turn off!")
self.white_pwm_label_text.set(self.white_pwm)
self.blue_pwm_label_text.set(self.blue_pwm)
self.red_pwm_label_text.set(self.red_pwm)
self.uv_pwm_label_text.set(self.uv_pwm)
self.ir_pwm_label_text.set(self.ir_pwm)
self.entry.delete(0, END)
def log_data(self, date, time, temperature, white, blue, red, uv, ir):
with open("LoggingData/log" + start_time.strftime("%m%d%Y-%H%M%S") +
".csv",
mode="a") as log_file:
ava_writer = csv.writer(log_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
ava_writer.writerow(
[date, time, temperature, white, blue, red, uv, ir])
def change_pwm(self, white_duty, blue_duty, red_duty, uv_duty, ir_duty,
check_temp):
if check_temp > 82:
pwm_w.ChangeDutyCycle(0)
pwm_b.ChangeDutyCycle(0)
pwm_r.ChangeDutyCycle(0)
pwm_uv.ChangeDutyCycle(0)
pwm_ir.ChangeDutyCycle(0)
else:
pwm_w.ChangeDutyCycle(white_duty)
pwm_b.ChangeDutyCycle(blue_duty)
pwm_r.ChangeDutyCycle(red_duty)
pwm_uv.ChangeDutyCycle(uv_duty)
pwm_ir.ChangeDutyCycle(ir_duty)
def stat_update(self):
time = datetime.datetime.now()
time_label = time.strftime("Time: %H:%M:%S")
elapsed_time = str(time - start_time)
temperature = (sensor.getTemp() - 32.0) * 5 / 9
temperature_label = "Temperature: " + str(temperature)
self.time_label.config(text=time_label)
self.elapsed_label.config(text="Elapsed Time: " + elapsed_time[:10])
self.temp_label.config(text=temperature_label)
self.change_pwm(self.white_pwm, self.blue_pwm, self.red_pwm,
self.uv_pwm, self.ir_pwm, temperature)
if (self.log_count > 2):
self.log_data(time.strftime("%m-%d-%Y"), time.strftime("%H:%M:%S"),
temperature, self.white_pwm, self.blue_pwm,
self.red_pwm, self.uv_pwm, self.ir_pwm)
self.log_count = 0
self.log_count = self.log_count + 1
self.master.after(self.timer_interval, self.stat_update)
class editPool(Frame):
font_decorations = ("italic", "bold", "subscript", "superscript")
font_decorations_to_names = {
"italic": _("italic"),
"bold": _("bold"),
"subscript": _("subscript"),
"superscript": _("superscript"),
}
font_decorations_to_html = {"italic": "i", "bold": "b", "subscript": "sub", "superscript": "sup"}
def __init__(self, master, buttons=("interpret", "asis"), **kw):
Frame.__init__(self, master, **kw)
self.text = ""
self.interpret = 1
self.editPool = Entry(self, width=50, state="disabled", font="Helvetica 12")
self.editPool.pack(side="left")
self.editPool.bind("<Return>", self._interpretButtonPressed)
self.editPool.bind("<Escape>", self._cancel)
self.editPool.bind("<Control-s>", lambda e: self._tag_it("sub"))
self.editPool.bind("<Control-S>", lambda e: self._tag_it("sup"))
self.editPool.bind("<Control-i>", lambda e: self._tag_it("i"))
self.editPool.bind("<Control-b>", lambda e: self._tag_it("b"))
self.editPool.bind("<KeyPress>", self._key)
if "interpret" in buttons:
pix = Store.app.request("pixmap", name="interpret")
self.interpretButton = Button(
self,
text=_("Interpret"),
image=pix,
command=self._interpretButtonPressed,
state="disabled",
bd=config.border_width,
)
Store.app.balloon.bind(self.interpretButton, _("Interpret text (where applicable)"))
self.interpretButton.pack(side="left")
else:
self.interpretButton = None
if "asis" in buttons:
pix = Store.app.request("pixmap", name="asis")
self.setButton = Button(
self,
image=pix,
text=_("As is"),
command=self._setButtonPressed,
state="disabled",
bd=config.border_width,
)
Store.app.balloon.bind(self.setButton, _("Leave text as is - do not interpret"))
self.setButton.pack(side="left")
else:
self.setButton = None
pix = Store.app.request("pixmap", name="subnum")
self.numbersToSubButton = Button(
self,
image=pix,
text=_("Sub numbers"),
command=self._numbersToSubButtonPressed,
state="disabled",
bd=config.border_width,
)
Store.app.balloon.bind(self.numbersToSubButton, _("Convert numbers to subscript"))
self.numbersToSubButton.pack(side="left")
# text decoration
decorFrame = Frame(self)
decorFrame.pack(padx=5, side="left")
for i in self.font_decorations:
pix = Store.app.request("pixmap", name=i)
self.__dict__[i] = Button(
self,
image=pix,
command=misc.lazy_apply(self._tag_it, (self.font_decorations_to_html[i],)),
state="disabled",
text=self.font_decorations_to_names[i],
bd=config.border_width,
)
Store.app.balloon.bind(self.__dict__[i], self.font_decorations_to_names[i])
self.__dict__[i].pack(side="left")
# special characters
pix = Store.app.request("pixmap", name="specialchar")
self.specialCharButton = Button(
self,
image=pix,
text=_("Special Character"),
command=self._specialCharButtonPressed,
state="disabled",
bd=config.border_width,
)
Store.app.balloon.bind(self.specialCharButton, _("Insert a special character"))
self.specialCharButton.pack(side="left")
self.active = False
def _interpretButtonPressed(self, *e):
t = self.editPool.get()
if string.lower(t) in groups_table:
self._setText(t)
# self._setText( groups_table[ string.lower(t)]['text'])
# self.editPool.insert(0, self.text)
else:
self._setText(t)
self.text = re.sub("\\\\n", "\n", self.text)
self._quit()
def _setButtonPressed(self, *e):
self._setText(self.editPool.get())
self.interpret = 0
self._quit()
def _numbersToSubButtonPressed(self, *e):
self._setText(re.sub("\d+", "<sub>\g<0></sub>", self.editPool.get()))
self._quit()
def _cancel(self, e):
self._setText(None)
self.active = False
self._quit()
def _quit(self):
self.grab_release()
self._disable()
self._normaly_terminated = 1
self.active = False
self.quit()
def _disable(self):
self.interpretButton.configure(state="disabled")
self.numbersToSubButton.configure(state="disabled")
self.setButton.configure(state="disabled")
self.editPool.configure(state="disabled")
self.italic.configure(state="disabled")
self.bold.configure(state="disabled")
self.superscript.configure(state="disabled")
self.subscript.configure(state="disabled")
self.specialCharButton.configure(state="disabled")
def _enable(self):
self.interpretButton.configure(state="normal")
self.numbersToSubButton.configure(state="normal")
self.setButton.configure(state="normal")
self.editPool.configure(state="normal")
self.italic.configure(state="normal")
self.bold.configure(state="normal")
self.superscript.configure(state="normal")
self.subscript.configure(state="normal")
self.specialCharButton.configure(state="normal")
def _setText(self, text):
self.text = text
self._update()
def _update(self):
self.editPool.delete(0, last="end")
if self.text:
self.editPool.insert(0, self.text)
def activate(self, text=None, select=1):
"""activates edit_pool and returns inserted value (None if cancel occured),
if parameter text is None it preserves the old one, use text='' to delete old text"""
self.active = True
self.interpret = 1
self.focus_set()
self.grab_set()
self._enable()
# this is because I need to distinguish whether the mainloop was terminated "from inside"
# or from outside (this most of the time means the application was killed and the widgets are no longer available)
self._normaly_terminated = 0
if text != None:
self._setText(text)
self.editPool.focus_set()
if select:
self.editPool.selection_range(0, "end")
self.mainloop()
if self._normaly_terminated:
return self.text
else:
return None
def _tag_it(self, tag):
if self.editPool.selection_present():
self.editPool.insert(Tkinter.SEL_FIRST, "<%s>" % tag)
self.editPool.insert(Tkinter.SEL_LAST, "</%s>" % tag)
else:
self.editPool.insert(Tkinter.INSERT, "<%s></%s>" % (tag, tag))
self.editPool.icursor(self.editPool.index(Tkinter.INSERT) - len(tag) - 3)
def _key(self, event):
if len(event.keysym) > 1 and event.keysym in keysyms:
if self.editPool.selection_present():
self.editPool.delete("anchor", "insert")
self.editPool.insert("insert", unicode(keysyms[event.keysym]))
return "break"
def _specialCharButtonPressed(self):
dialog = special_character_menu(self._insertText)
dialog.post(self.specialCharButton.winfo_rootx(), self.specialCharButton.winfo_rooty())
def _insertText(self, text):
if text != None:
self.editPool.insert(Tkinter.INSERT, text)
self.grab_set()
class WindowExample(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.result = 0
self.master.title("This is a test")
self.master.minsize(width = 600, height = 800)
#self.master.
self.prompt = Label(self, text = "Enter a number:", anchor = "w", fg = "#984301")
self.entry = Entry(self, width = 50, highlightcolor = "red")
self.submit = Button(self, text = "Submit", command = self.calculate)
self.exit = Button(self, text = "Exit", command = parent.destroy, fg = "red")
self.output = Label(self, text = "")
self.menu = Menu(self, title = "Menu test", bg = "black")
self.canvas = Canvas(self, cursor = "circle", highlightcolor = "blue", bg = "#019bf0")
self.button1 = Button(self, text = "tast antum", bg = "red", fg = "green", command = self.newWindow, \
activebackground = "red", activeforeground = "blue", relief = "sunken", cursor = "dot")
self.newFrame = Frame(self, bg = "green", highlightcolor = "blue")
self.button2 = Button(self.newFrame, text = "This is a tast")
self.button2.grid()
self.scale = Scale(self, from_ = 50, to_ = 60, orient = "horizontal", digits = 3, resolution = 0.25, highlightcolor = "red", command = self.calculate)
self.scale.pack()
self.open_file_button = Button(self, text = "Open File", command = self.openFile)
self.prompt.pack(side = "top", fill = "x")
self.entry.pack(side = "top", fill = "x")
self.output.pack(side = "top", fill = "x", expand = True)
self.submit.pack(side = "right")
self.exit.pack(side = "left")
self.button1.pack(fill="x")
self.newFrame.pack(side="bottom", fill = "x", expand = True)
self.button2.grid()
self.canvas.pack()
self.open_file_button.pack()
#self.slider.pack()
#self.tk = Tkinter.Tk()
#self.tk.withdrow()
#self.file_path = Tkinter.filedialog.askopenfilename()
#print("test")
self.entry.insert(string = "3", index = 0)
#self.entry.insert(string = "blahblah", index = 3)
def calculate(self, integer):
integer = float(integer)
#try:
# i = int(self.entry.get())
# self.result = "%s*2=%s" % (i, i*2)
#except ValueError:
# self.result = "Please enter numbers only"
self.entry.delete(0, len(self.entry.get()))
self.result = "%s*2=%s" % (integer, integer*2)
self.entry.insert(0, integer)
self.output.configure(text=self.result)
def newWindow(self):
try:
r2 = Tk()
r2.mainloop()
except ValueError:
return None
def openFile(self):
file_in = tkFileDialog.askopenfilename()
self.output.configure(text = file_in)
class GUI:
def __init__(self, master):
self.master = master
master.title("Naive Bayes Classifier")
#set up vars for gui logic
self.browse_text = StringVar()
self.val_bins = master.register(self.validate_bins)
self.isBin = False
self.isBrowse = False
self.isTest = ''
self.isBrowse = ''
self.isTrain = ''
#buttons
self.button_browse = Button(master,
text='Browse',
command=lambda: self.DisplayDir())
self.button_build = Button(master,
text="Build",
command=lambda: self.build())
self.button_classify = Button(master,
text="Classify",
command=lambda: self.classify())
#labels
self.label_directory_path = Label(master, text="Directory Path")
self.label_bins = Label(master, text="Discretization Bins")
self.label_error = Label(master, text="", fg='red')
#entries
self.entry_browse = Entry(master, width=50)
self.entry_bins = Entry(master,
width=50,
validatecommand=(self.val_bins, "%P", "%d"),
validate='key')
# LAYOUT
self.button_browse.grid(row=1, column=4)
self.entry_browse.grid(row=1, column=2, columnspan=2)
self.label_directory_path.grid(row=1, column=1)
self.label_bins.grid(row=2, column=1)
self.entry_bins.grid(row=2, column=2)
self.button_build.grid(row=3, column=1)
self.button_classify.grid(row=3, column=2)
self.label_error.grid(row=4, column=2)
self.master.minsize(width=700, height=200)
#control buttons
self.button_build['state'] = 'disabled'
self.button_classify['state'] = 'disabled'
# #Logic
self.modelBuilder = '' # build the model
self.modelTrainer = ModelTrainer.ModelTrainer(
) # use the train file and clean it
self.modelTest = ModelTest.ModelTest()
self.modelClassifier = '' #classification
def validate_bins(self, v, d):
try:
value = int(v)
if value > 1:
if self.isBrowse:
self.button_build['state'] = 'normal'
return True
else:
self.isBin = False
tkMessageBox.showinfo("Alert Message", "Invalid number")
return False
except:
if d == '0' and v == '':
self.entry_bins.delete(1, 'end')
if len(self.entry_bins.get()) == 1:
self.button_build['state'] = 'disabled'
self.button_classify['state'] = 'disabled'
self.isBin = False
return True
tkMessageBox.showinfo("Alert Message", "Invalid number")
return False
def build(self):
self.label_error.config(text="Begin building")
self.modelBuilder = ModelBuilder.ModelBuilder(self.isStructure)
self.modelTrainer = ModelTrainer.ModelTrainer(self.isTrain,
self.modelBuilder,
self.entry_bins.get())
self.modelTrainer.readFile()
maxbins = self.modelTrainer.getMaxbins()
if maxbins < int(self.entry_bins.get()):
tkMessageBox.showinfo("Alert Message", "Invalid number of bins")
elif os.stat(self.isTest).st_size == 0 or os.stat(
self.isTrain).st_size == 0 or os.stat(
self.isStructure).st_size == 0:
tkMessageBox.showinfo("Alert Message", "One of the files is empty")
else:
self.modelTrainer.fillMissingValues()
self.modelTrainer.discretization()
tkMessageBox.showinfo(
"Alert Message",
"Building classifier using train-set is done!")
self.button_classify['state'] = 'normal'
self.label_error.config(text='')
def classify(self):
self.modelTest.setdata(self.isTest, self.modelBuilder,
self.entry_bins.get())
self.modelTest.cleanData()
self.modelClassifier = ModelClassifier.ModelClassifier(
self.entry_browse.get(), self.modelTrainer.getData(),
self.modelTest.getData(), self.modelBuilder, self.entry_bins.get())
self.modelClassifier.buildNaiveDictionary()
self.modelClassifier.classify()
self.modelClassifier.writeOutput()
tkMessageBox.showinfo(
"Alert Message",
"Done classifying. output is ready in : {}".format(
self.entry_browse.get()))
def DisplayDir(self):
feedback = askdirectory()
self.browse_text.set(feedback)
self.entry_browse.config(state='normal')
self.entry_browse.delete(0, 'end')
self.entry_browse.insert(0, self.browse_text.get())
self.entry_browse.config(state='readonly')
self.isTest = os.path.join(self.browse_text.get(), "test.csv")
self.isTrain = os.path.join(self.browse_text.get(), "train.csv")
self.isStructure = os.path.join(self.browse_text.get(),
"Structure.txt")
self.texterror = ""
if (os.path.exists(self.isTest) and os.path.exists(self.isTrain)
and os.path.exists(self.isStructure)):
if self.isBin:
self.button_build['state'] = 'normal'
self.button_classify['state'] = 'normal'
self.label_error.config(text='folder content is valid !')
else:
self.texterror = "please fill bin text field"
self.isBrowse = True
else:
if (not os.path.exists(self.isTrain)
# and not os.path.exists(self.isStructure)
and not os.path.exists(self.isTest)):
self.texterror = "train.csv , structure.txt and test.csv were not found"
elif (not os.path.exists(self.isTrain)):
self.texterror = "train.csv was not found"
elif (not os.path.exists(self.isStructure)):
self.texterror = "Structure.txt was not found"
elif (not os.path.exists(self.isTest)):
self.texterror = "test.csv was not found"
self.isBrowse = False
self.label_error.config(text=self.texterror)
class Chatbox(object):
def __init__(self,
master,
my_nick=None,
command=None,
topic=None,
entry_controls=None,
maximum_lines=None,
timestamp_template=None,
scrollbar_background=None,
scrollbar_troughcolor=None,
history_background=None,
history_font=None,
history_padx=None,
history_pady=None,
history_width=None,
entry_font=None,
entry_background=None,
entry_foreground=None,
label_template=u"{nick}",
label_font=None,
logging_file=None,
tags=None):
self.interior = Frame(master, class_="Chatbox")
self._command = command
self._is_empty = True
self._maximum_lines = maximum_lines
self._timestamp_template = timestamp_template
self._command = command
self._label_template = label_template
self._logging_file = logging_file
if logging_file is None:
self._log = None
else:
try:
self._log = open(logging_file, "r")
except:
self._log = None
top_frame = Frame(self.interior, class_="Top")
top_frame.pack(expand=True, fill=BOTH)
self._textarea = Text(top_frame, state=DISABLED)
self._vsb = Scrollbar(top_frame,
takefocus=0,
command=self._textarea.yview)
self._vsb.pack(side=RIGHT, fill=Y)
self._textarea.pack(side=RIGHT, expand=YES, fill=BOTH)
self._textarea["yscrollcommand"] = self._vsb.set
entry_frame = Frame(self.interior, class_="Chatbox_Entry")
entry_frame.pack(fill=X, anchor=N)
if entry_controls is not None:
controls_frame = Frame(entry_frame, class_="Controls")
controls_frame.pack(fill=X)
entry_controls(controls_frame, chatbox=self)
bottom_of_entry_frame = Frame(entry_frame)
self._entry_label = Label(bottom_of_entry_frame)
self._entry = Entry(bottom_of_entry_frame)
else:
self._entry_label = Label(entry_frame)
self._entry = Entry(entry_frame)
self._entry.pack(side=LEFT, expand=YES, fill=X)
self._entry.bind("<Return>", self._on_message_sent)
self._entry.focus()
if history_background:
self._textarea.configure(background=history_background)
if history_font:
self._textarea.configure(font=history_font)
if history_padx:
self._textarea.configure(padx=history_padx)
if history_width:
self._textarea.configure(width=history_width)
if history_pady:
self._textarea.configure(pady=history_pady)
if scrollbar_background:
self._vsb.configure(background=scrollbar_background)
if scrollbar_troughcolor:
self._vsb.configure(troughcolor=scrollbar_troughcolor)
if entry_font:
self._entry.configure(font=entry_font)
if entry_background:
self._entry.configure(background=entry_background)
if entry_foreground:
self._entry.configure(foreground=entry_foreground)
if label_font:
self._entry_label.configure(font=label_font)
if tags:
for tag, tag_config in tags.items():
self._textarea.tag_config(tag, **tag_config)
self.set_nick(my_nick)
@property
def topic(self):
return
@topic.setter
def topic(self, topic):
return
def focus_entry(self):
self._entry.focus()
def bind_entry(self, event, handler):
self._entry.bind(event, handler)
def bind_textarea(self, event, handler):
self._textarea.bind(event, handler)
def bind_tag(self, tagName, sequence, func, add=None):
self._textarea.tag_bind(tagName, sequence, func, add=add)
def focus(self):
self._entry.focus()
def user_message(self, nick, content):
if self._timestamp_template is None:
self._write((u"%s:" % nick, "nick"), " ",
(content, "user_message"))
else:
timestamp = datetime.datetime.now().strftime(
self._timestamp_template)
self._write((timestamp, "timestamp"), " ", (u"%s:" % nick, "nick"),
" ", (content, "user_message"))
def notification_message(self, content, tag=None):
if tag is None:
tag = "notification"
self._write((content, tag))
notification = notification_message
def notification_of_private_message(self, content, from_, to):
if self._timestamp_template is None:
self.notification_message(
u"{from_} -> {to}: {content}".format(from_=from_,
to=to,
content=content),
"notification_of_private_message")
else:
timestamp = datetime.datetime.now().strftime(
self._timestamp_template)
self.notification_message(
u"{timestamp} {from_} -> {to}: {content}".format(
timestamp=timestamp, from_=from_, to=to, content=content),
"notification_of_private_message")
def new_message(self, message):
if isinstance(message, User_Message):
self.user_message(message.content, message.nick)
elif isinstance(message, Notification_Message):
self.notification(message.content, message.tag)
elif isinstance(message, Notification_Of_Private_Message):
self.notification_of_private_message(message.from_, message.to,
message.content)
else:
raise Exception("Bad message")
def tag(self, tag_name, **kwargs):
self._textarea.tag_config(tag_name, **kwargs)
def clear(self):
self._is_empty = True
self._textarea.delete('1.0', END)
@property
def logging_file(self):
return self._logging_file
def send(self, content):
if self._my_nick is None:
raise Exception("Nick not set")
self.user_message(self._my_nick, content)
def _filter_text(self, text):
return "".join(ch for ch in text if ch <= u"\uFFFF")
def _write(self, *args):
if len(args) == 0: return
relative_position_of_scrollbar = self._vsb.get()[1]
self._textarea.config(state=NORMAL)
if self._is_empty:
self._is_empty = False
else:
self._textarea.insert(END, "\n")
if self._log is not None:
self._log.write("\n")
for arg in args:
if isinstance(arg, tuple):
text, tag = arg
# Parsing not allowed characters
text = self._filter_text(text)
self._textarea.insert(END, text, tag)
else:
text = arg
text = self._filter_text(text)
self._textarea.insert(END, text)
if self._log is not None:
self._log.write(text)
if self._maximum_lines is not None:
start_line = int(self._textarea.index('end-1c').split('.')
[0]) - self._maximum_lines
if lines_to_delete >= 1:
self._textarea.delete('%s.0' % start_line, END)
self._textarea.config(state=DISABLED)
if relative_position_of_scrollbar == 1:
self._textarea.yview_moveto(1)
def _on_message_sent(self, event):
message = self._entry.get()
self._entry.delete(0, END)
self.send(message)
if self._command:
self._command(message)
def set_nick(self, my_nick):
self._my_nick = my_nick
if my_nick:
text = self._label_template.format(nick=my_nick)
self._entry_label["text"] = text
self._entry_label.pack(side=LEFT, padx=(5, 5), before=self._entry)
else:
self._entry_label.pack_forget()
class GuessingGame:
def __init__(self, master):
self.master = master
master.title("Guessing Game")
self.secret_number = random.randint(1, 100)
self.guess = None
self.num_guesses = 0
self.message = "Guess a number from 1 to 100"
self.label_text = StringVar()
self.label_text.set(self.message)
self.label = Label(master, textvariable=self.label_text)
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.guess_button = Button(master, text="Guess", command=self.guess_number)
self.reset_button = Button(master, text="Play again", command=self.reset, state=DISABLED)
self.label.grid(row=0, column=0, columnspan=2, sticky=W+E)
self.entry.grid(row=1, column=0, columnspan=2, sticky=W+E)
self.guess_button.grid(row=2, column=0)
self.reset_button.grid(row=2, column=1)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.guess = None
return True
try:
guess = int(new_text)
if 1 <= guess <= 100:
self.guess = guess
return True
else:
return False
except ValueError:
return False
def guess_number(self):
self.num_guesses += 1
if self.guess is None:
self.message = "Guess a number from 1 to 100"
elif self.guess == self.secret_number:
suffix = '' if self.num_guesses == 1 else 'es'
self.message = "Congratulations! You guessed the number after %d guess%s." % (self.num_guesses, suffix)
self.guess_button.configure(state=DISABLED)
self.reset_button.configure(state=NORMAL)
elif self.guess < self.secret_number:
self.message = "Too low! Guess again!"
else:
self.message = "Too high! Guess again!"
self.label_text.set(self.message)
def reset(self):
self.entry.delete(0, END)
self.secret_number = random.randint(1, 100)
self.guess = 0
self.num_guesses = 0
self.message = "Guess a number from 1 to 100"
self.label_text.set(self.message)
self.guess_button.configure(state=NORMAL)
self.reset_button.configure(state=DISABLED)
class GuessingGame:
def __init__(self, master):
self.master = master
master.title("Ultra Difficult Phrasing")
self.secret_number = random.randint(1, 100)
self.guess = None
self.num_guesses = 0
self.message = "Try to type the message!"
self.label_text = StringVar()
self.label_text.set(self.message)
self.label = Label(master, textvariable=self.label_text)
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.guess_button = Button(master, text="Check", command=self.guess_number, foreground="green")
self.reset_button = Button(master, text="Reset", command=self.reset, foreground="red")
self.label.grid(row=0, column=0, columnspan=2, sticky=W+E)
self.entry.grid(row=1, column=0, columnspan=2, sticky=W+E)
self.guess_button.grid(row=2, column=0)
self.reset_button.grid(row=2, column=1)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.guess = None
return True
try:
guess = String(new_text)
if 1 <= guess <= 100:
self.guess = guess
return True
else:
return False
except ValueError:
return False
def guess_number(self):
self.num_guesses += 1
if self.guess is None:
self.message = "Try to type the message!"
elif self.guess == self.secret_number:
suffix = '' if self.num_guesses == 1 else 'es'
self.message = "Congratulations! You guessed the number after %d guess%s." % (self.num_guesses, suffix)
self.guess_button.configure(state=DISABLED)
self.reset_button.configure(state=NORMAL)
elif self.guess < self.secret_number:
self.message = "Too low! Guess again!"
else:
self.message = "Too high! Guess again!"
self.label_text.set(self.message)
def reset(self):
self.entry.delete(0, END)
self.secret_number = random.randint(1, 100)
self.guess = 0
self.num_guesses = 0
self.message = "Try to type the message:"
self.label_text.set(self.message)
self.guess_button.configure(state=NORMAL)
self.reset_button.configure(state=NORMAL)
class Input:
"""
(TO DO)
"""
#================================================================
def __init__(self, master, t1="x", t2="", name=""):
"""
(TO DO)
"""
if name == "":
self.label1 = Label(master, text=t1)
self.label2 = Label(master, text=t2)
self.tBox = Entry(master)
else:
self.label1 = Label(master, text=t1, name=("lb1_" + name))
self.label2 = Label(master, text=t2, name=("lb2_" + name))
self.tBox = Entry(master, name=("tbox_" + name))
#================================================================
def __call__(self, cFactor=1.):
"""
(TO DO)
"""
return self.get(cFactor)
#===============================================================
def get(self, cFactor=1.):
"""
(TO DO)
"""
tmp = float(self.tBox.get())
return tmp * cFactor
#================================================================
def set(self, value):
"""
(TO DO)
"""
self.tBox.delete(0, END)
self.tBox.insert(0, value)
#================================================================
def enable(self):
"""
(TO DO)
"""
self.label1.config(state=NORMAL)
self.label2.config(state=NORMAL)
self.tBox.config(state=NORMAL)
#================================================================
def disable(self):
"""
(TO DO)
"""
self.label1.config(state=DISABLED)
self.label2.config(state=DISABLED)
self.tBox.config(state=DISABLED)
class GUIClient(object):
"""
Wrapper used to control sockets and widgets
"""
def __init__(self, host, port, queue, thread_client):
"""
@param host: unicode
@param port: int
@param queue: Queue
"""
# initialization
self.threaded_client=thread_client
# Constants
self.TEXT_WIDTH = 150
self.INPUT_WIDTH = self.TEXT_WIDTH - self.TEXT_WIDTH/3
# Connecting socket
self.queue = queue
self.socket = socket(AF_INET, SOCK_STREAM)
self.socket.connect((host, port))
# Mount widgets
scrollbar = Scrollbar()
scrollbar.pack(side=RIGHT, fill=Y)
self.text = Text(width=self.TEXT_WIDTH, yscrollcommand=scrollbar.set)
self.text.pack(side=TOP)
self.input = Entry(width=self.INPUT_WIDTH)
self.input.pack(side=LEFT)
self.send = Button(text="Send a message", command=self.send_message)
self.send.pack(side=LEFT)
self.input.bind("<Return>", self.send_message)
def receive_message(self, msg):
"""
Receive message from socket and move scrollbar to end.
"""
quit = re.search('^/quit_maximum.*', msg)
if quit:
print "Server has reached maximum of clients connected."
self.threaded_client.close()
return
self.text.insert(END, msg + "\n")
self.text.see(END)
def send_message(self, *args, **kwargs):
"""
Send message to server and clean Entry widget.
"""
msg = self.input.get()
self.input.delete(0, END)
quit = re.search('^/quit.*', msg)
self.socket.send(msg)
if quit:
self.threaded_client.close()
def incoming(self):
"""
Handle all the messages currently in the queue (if any).
"""
while self.queue.qsize():
try:
msg = self.queue.get(0)
# Check contents of message and do what it says
# As a test, we simply print it
self.receive_message(msg)
except Empty:
pass
def disconnect(self):
"""
Disconnect socket
"""
self.socket.close()
class App:
def __init__(self, master):
self.master = master
self.file = 'grid.csv'
self.ownZepName = "goud"
self.updatingFlag = False
self.btnUpPressed = False
self.btnDownPressed = False
self.btnLeftPressed = False
self.btnRightPressed = False
self.btnPlusPressed = False
self.btnMinusPressed = False
#keyListener aanzetten
master.bind("<Key>", self.keyPressed)
master.bind("<KeyRelease>", self.keyReleased)
leftFrame = Frame(master, width = 200, height = 640)
leftFrame.grid(row = 0, column = 0)
debugFrame = Frame(leftFrame, width = 200, height = 400)
debugFrame.grid(row = 0, column = 0)
controlFrame = Frame(leftFrame, width = 200, height = 200)
controlFrame.grid(row = 1, column = 0, pady = 10)
rasterFrame = Frame(master, width = 600, height = 640)
rasterFrame.grid(row = 0, column = 1)
#Scrolledtext in leftTopFrame
self.scrDebug = ScrolledText(debugFrame, wrap = WORD, state = "disabled", fg = "dark red", width=80)
self.scrDebug.grid(row = 0, column = 0, padx = 10, pady = 10)
#Buttons
#simulator
self.btnToggleSimu = Button(controlFrame, text = "Simulator", width = 14, bg = 'gray85', command = lambda: self.toggleSimulator())
self.btnToggleSimu.grid(row = 3, column = 2)
self.btnMoveToSimu = Button(controlFrame, text = "Ga naar (Sim)", width = 14, bg = 'gray85', command = lambda: self.moveTo(Name = "goudsimu"))
self.btnMoveToSimu.grid(row = 1, column = 4)
self.btnHeightSimu = Button(controlFrame, text = "Kies hoogte (Sim)", width = 14, bg = 'gray85', command = lambda: self.setGewensteHoogte(Name ="goudsimu"))
self.btnHeightSimu.grid(row = 2, column = 4)
#hoogte
self.gemetenHoogteString = StringVar()
self.gemetenHoogteString.set(str(0))
self.lblGemetenHoogte = Label(controlFrame, text="Gemeten Hoogte: ", anchor = "w")
self.lblGemetenHoogteVar = Label(controlFrame, textvariable = self.gemetenHoogteString, width = 20)
self.lblGemetenHoogte.grid(row=0, column=2)
self.lblGemetenHoogteVar.grid(row=0, column=3)
#move to
self.btnMoveTo = Button(controlFrame, text="Ga naar (Zep)", bg = 'gray85', width = 14, command = lambda: self.moveTo())
self.btnMoveTo.grid(row=1,column=2)
self.txtMoveTo = Entry(controlFrame, width=24)
self.txtMoveTo.grid(row=1, column=3)
self.txtMoveTo.bind('<Return>', self.moveTo)
#hoogte
self.btnHeight = Button(controlFrame, text="Kies hoogte (Zep)", bg = 'gray85', width = 14, command = lambda: self.setGewensteHoogte())
self.btnHeight.grid(row=2,column=2)
self.txtHeight = Entry(controlFrame, width=24)
self.txtHeight.grid(row=2, column=3)
self.txtHeight.bind('<Return>', self.setGewensteHoogte)
#images
self.display = Canvas(rasterFrame, width=600, height=570, bd=0, highlightthickness=0)
self.display.grid(row=0, column = 0, sticky=W+E+N+S)
foundFigures = Label(controlFrame, text = "Herkende figuren:")
foundFigures.grid(row = 0, column = 0)
self.display2 = Canvas(controlFrame, width = 220, height=165, bd=2, relief = "groove", highlightthickness=0)
self.display2.grid(row=1, column = 0, sticky=W+E+N+S, rowspan=12)
self.latestphoto = Image.new("RGB", (220,165), (150,150,150))
self.latestImage = ImageTk.PhotoImage(self.latestphoto)
self.display2.create_image(0, 0, image=self.latestImage, anchor=NW)
#goal
original = Image.open('goalPin.png')
resized = original.resize((60,60),Image.ANTIALIAS)
self.goalImage = ImageTk.PhotoImage(resized)
self.makeBackground()
self.initZeppelins()
self.paintCanvas()
self.sim = None
mq.setGUI(self)
def initZeppelins(self):
self.zeppelins = []
self.goal = (-100,-100)
# self.zeppelins.append(AbstractZeppelin('red', 'simu'))
self.zeppelins.append(AbstractZeppelin('#EBB400', self.ownZepName))
def convToPixelCoords(self, pos):
cmHeight = 34.6410162
cmWidth = 40.0
xcm, ycm = pos
x = self.evenXStart + (xcm/cmWidth)*self.triangleWidth
y = self.yStart + (ycm/cmHeight)*self.triangleHeight
result = (x,y)
return result
def createPhoto(self, cvresults):
self.latestphoto = Image.new("RGB", (220,165), (150,150,150))
cv = eval(cvresults)
width = cv[0]
height = cv[1]
figures = cv[2]
coordinates = cv[3]
for i in xrange(0,len(figures)):
j = self.allShapes.index(figures[i])
image = self.shapeImages[j]
xcoord = int(coordinates[i][0]/(width*1.0)*220)
ycoord = int(coordinates[i][1]/(height*1.0)*165)
self.latestphoto.paste(image, (xcoord-12, ycoord-12), mask = image)
self.latestImage = ImageTk.PhotoImage(self.latestphoto)
self.display2.create_image(0, 0, image=self.latestImage, anchor=NW)
def makeBackground(self):
#rooster inlezen:
f = open("../positioning/"+ str(self.file), 'r')
shapesText = f.read()
self.raster = []
self.tabletLocations = []
nrows = 0
ncol = 0
for line in shapesText.split("\n"):
temp = line.split(",")
if not len(temp) == 2:
nrows += 1
if ncol == 0:
ncol = len(temp)
for s in temp:
self.raster.append(s.strip())
else:
self.tabletLocations.append((int(temp[0]), int(temp[1])))
f.close()
tempWidth1 = 600/ncol
tempHeight1 = int(round((math.sqrt(tempWidth1**2 - (tempWidth1/2)**2)), 0))
tempHeight2 = 570/nrows+2
tempWidth2 = int(round((math.sqrt(4/3 * tempHeight2**2)),0))
#raster
self.resizedRaster = Image.new("RGB", (600,570), (240,240,240))
#vormpjes
self.allShapes = ['BC','BH','BR','BS','GC','GH','GR','GS','RC','RH','RR','RS','WC','WH','WR','WS','YC','YH','YR','YS']
self.shapeImages = []
for i in range(20):
imgFile = "vormpjes/" + self.allShapes[i] + ".png"
original = Image.open(imgFile)
self.shapeImages.append(original.resize((24, 24),Image.ANTIALIAS))
original = Image.open("tablet.png")
self.tabletIm = original.resize((40,40),Image.ANTIALIAS)
self.xlen = ncol
self.ylen = nrows
self.triangleWidth = min(tempWidth1, tempWidth2)
self.triangleHeight = min(tempHeight1, tempHeight2)
self.evenXStart = (600-((ncol)*self.triangleWidth))/2 + self.triangleWidth/4
self.oddXStart = self.evenXStart + self.triangleWidth/2
self.yStart = (600-((nrows)*self.triangleHeight))/2 + self.triangleHeight/4
draw = ImageDraw.Draw(self.resizedRaster)
#grid tekenen
for y in range(self.ylen):
for x in range(self.xlen):
ycoord = self.yStart + y*self.triangleHeight
zelf = self.raster[y*self.xlen + x] != "XX"
if y>0:
boven = self.raster[(y-1)*self.xlen + x] != "XX"
if y<self.ylen-1:
onder = self.raster[(y+1)*self.xlen + x] != "XX"
if y>0 and x < self.xlen-1:
oddboven = self.raster[(y-1)*self.xlen + x+1] != "XX"
if y<self.ylen-1 and x < self.xlen-1:
oddonder = self.raster[(y+1)*self.xlen + x+1] != "XX"
if x<self.xlen-1:
naast = self.raster[y*self.xlen + x+1] != "XX"
if y % 2 == 0:
xcoord = self.evenXStart + x*self.triangleWidth
if x < self.xlen-1 and naast and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth, ycoord), fill = 0)
if y < self.ylen-1 and onder and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord+self.triangleHeight), fill = 0)
if y > 0 and boven and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord-self.triangleHeight), fill = 0)
else:
xcoord = self.oddXStart + x*self.triangleWidth
if x < self.xlen-1 and naast and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth, ycoord), fill = 0)
if y < self.ylen-1 and x < self.xlen-1 and oddonder and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord+self.triangleHeight), fill = 0)
if y > 0 and x < self.xlen-1 and oddboven and zelf:
draw.line((xcoord, ycoord, xcoord+self.triangleWidth/2, ycoord-self.triangleHeight), fill = 0)
del draw
for loc in self.tabletLocations:
conv = self.convToPixelCoords((loc[0]/10, loc[1]/10))
self.resizedRaster.paste(self.tabletIm, (int(conv[0])-20, int(conv[1])-20), mask = self.tabletIm)
#vormpjes tekenen
for y in range(self.ylen):
for x in range(self.xlen):
index = y*self.xlen + x
if y % 2 == 0:
xcoord = self.evenXStart + x*self.triangleWidth
else:
xcoord = self.oddXStart + x*self.triangleWidth
ycoord = self.yStart + y*self.triangleHeight
shape = self.raster[index]
if shape != 'XX':
image = self.shapeImages[self.allShapes.index(shape)]
self.resizedRaster.paste(image, (xcoord-12, ycoord-12), mask = image)
self.rasterImage = ImageTk.PhotoImage(self.resizedRaster)
def updatePath(self):
self.rasterBackup = self.rasterImage
draw = ImageDraw.Draw(self.resizedRaster)
for z in self.zeppelins:
length = len(z.locations)
if length > 1:
prev = self.convToPixelCoords(z.locations[length-2])
current = self.convToPixelCoords(z.locations[length-1])
draw.line((prev[0], prev[1], current[0], current[1]), fill=z.color, width = 3)
self.rasterImage = ImageTk.PhotoImage(self.resizedRaster)
del draw
def paintCanvas(self):
#clear the canvas
#self.display.delete('all')
#rooster tekenen
self.updatePath()
self.display.create_image(0, 0, image=self.rasterImage, anchor=NW)
#Testcode voor zeppelin locatie
for z in self.zeppelins:
if z.orientationFound:
point1x = self.convToPixelCoords(z.location)[0]+16*math.sin(math.radians(z.orientation + 20))
point1y = self.convToPixelCoords(z.location)[1]+16*math.cos(math.radians(z.orientation + 20))
point2x = self.convToPixelCoords(z.location)[0]+16*math.sin(math.radians(z.orientation - 20))
point2y = self.convToPixelCoords(z.location)[1]+16*math.cos(math.radians(z.orientation - 20))
point3x = self.convToPixelCoords(z.location)[0]+28*math.sin(math.radians(z.orientation))
point3y = self.convToPixelCoords(z.location)[1]+28*math.cos(math.radians(z.orientation))
arrowPoints = [point1x, point1y, point2x, point2y, point3x, point3y]
self.display.create_polygon(arrowPoints, fill=z.color, outline='black', width = 1)
self.display.create_oval(self.convToPixelCoords(z.location)[0]-12, self.convToPixelCoords(z.location)[1]-12,self.convToPixelCoords(z.location)[0]+12, self.convToPixelCoords(z.location)[1]+12, fill=z.color)
self.display.create_image(self.convToPixelCoords(self.goal)[0]+6, self.convToPixelCoords(self.goal)[1]-18, image = self.goalImage, anchor=CENTER)
def toggleSimulator(self):
if self.sim == None:
enemy = "goudsimu"
self.zeppelins.append(AbstractZeppelin("red", enemy))
mq.initEnemy(enemy)
self.sim = simulator.simulator(100,100, enemy)
return
self.sim.toggleActive()
def updateGoal(self, location, tablet):
self.debugPrint("Nieuw doel voor simulator: " + str(tablet) + " " + str(location))
self.goal = self.convToPixelCoords(location)
self.paintCanvas()
def updateLocation(self, location, n):
self.debugPrint("Nieuwe locatie voor " + n + " ontvangen: " + str(location))
for z in self.zeppelins:
if z.name == n:
z.updateLocation((location[0]/10, location[1]/10))
self.paintCanvas()
def updateHeight(self, height, n):
self.debugPrint("Nieuwe hoogte voor " + n + " ontvangen: " + str(height))
if self.ownZepName == n:
self.gemetenHoogteString.set(str(height))
def updateAngle(self, angle, n):
self.debugPrint("Nieuwe orientatie voor " + n + " ontvangen: " + str(angle) + " graden")
for z in self.zeppelins:
if z.name == n:
z.updateAngle(angle)
self.paintCanvas()
def showCvResults(self, body):
self.debugPrint("Nieuwe foto vertaling ontvangen: " + body)
self.createPhoto(body)
#gewenste hoogte aanpassen
def setGewensteHoogte(self, event = None, Name = "goud"):
x = self.txtHeight.get()
self.txtHeight.delete(0, END)
self.master.focus()
try:
x = int(x)
except:
return
if isinstance(x, int) and x > 0 and x < 8000:
global neededHeight
neededHeight = x
message = "Hoogte instellen op " + str(neededHeight) + " aangevraagd"
self.debugPrint(message)
mq.elevate(x, Name)
#gewenste hoogte aanpassen
def moveTo(self, event = None, Name = "goud"):
st = self.txtMoveTo.get()
self.txtMoveTo.delete(0, END)
self.master.focus()
try:
xst, yst = st.split(',')
x = int(xst)
y = int(yst)
except:
return
if isinstance(x, int) and isinstance(y, int):
message = "Bewegen naar (" + str(x) + "," + str(y) + ") aangevraagd"
self.debugPrint(message)
self.goal = x/10,y/10
self.paintCanvas()
mq.moveTo(x, y, Name)
#tekst weergeven in debug venster
def debugPrint(self, tekst):
self.scrDebug.config(state = "normal")
self.scrDebug.insert(END, ">> " + tekst + "\n")
self.scrDebug.config(state = "disabled")
self.scrDebug.yview_pickplace("end")
def toggleAutomaticPilot(self):
if not self.connected:
return
self.debugPrint("Automatische piloot toggle aangevraagd")
self.client.toggleAutomaticPilot()
def createClient(self):
try:
self.client = cl(self, self.ownZepName)
self.zeppelins.append(AbstractZeppelin('red', self.ownZepName, self, self.client))
self.connected = True
self.connectedString.set("Verbonden")
self.lblConnected.config(fg = "green")
self.debugPrint("Verbonden met Raspberry Pi")
except:
self.debugPrint("Verbinding met Rapsberry Pi niet mogelijk:\n -Staat de Raspberry Pi aan?\n -Staat de server aan?\n -Zit deze computer op de ad-hoc?")
def moveForward(self):
self.debugPrint("Voorwaarts vliegen aangevraagd")
mq.setMotor1PWM(100)
mq.setMotor2PWM(100)
def moveBackward(self):
self.debugPrint("Achterwaarts vliegen aangevraagd")
mq.setMotor1PWM(-100)
mq.setMotor2PWM(-100)
def moveLeft(self):
self.debugPrint("Links draaien aangevraagd")
mq.setMotor1PWM(100)
def moveRight(self):
self.debugPrint("Rechts draaien aangevraagd")
mq.setMotor2PWM(100)
def moveUp(self):
self.debugPrint("Omhoog vliegen aangevraagd")
mq.setMotor3PWM(100)
def moveDown(self):
self.debugPrint("Omlaag vliegen aangevraagd")
mq.setMotor3PWM(-100)
def horizontalOff(self):
self.debugPrint("Horizontale motors stoppen aangevraagd")
mq.setMotor1PWM(0)
mq.setMotor2PWM(0)
def verticalOff(self):
self.debugPrint("Verticale motor stoppen aangevraagd")
mq.setMotor3PWM(0)
#toetsenbord invoer
def keyPressed(self, event):
k = event.keysym
if k == 'Up':
if not self.btnUpPressed:
self.btnUpPressed = True
self.moveForward()
elif k == 'Down':
if not self.btnDownPressed:
self.btnDownPressed = True
self.moveBackward()
elif k == 'Left':
if not self.btnLeftPressed:
self.btnLeftPressed = True
self.moveLeft()
elif k == 'Right':
if not self.btnRightPressed:
self.btnRightPressed = True
self.moveRight()
elif k == 'plus':
if not self.btnPlusPressed:
self.btnPlusPressed = True
self.moveUp()
elif k == 'minus':
if not self.btnMinusPressed:
self.btnMinusPressed = True
self.moveDown()
def keyReleased(self, event):
k = event.keysym
if k == 'Up':
self.btnUpPressed = False
self.horizontalOff()
elif k == 'Down':
self.btnDownPressed = False
self.horizontalOff()
elif k == 'Left':
self.btnLeftPressed = False
self.horizontalOff()
elif k == 'Right':
self.btnRightPressed = False
self.horizontalOff()
elif k == 'plus':
self.btnPlusPressed = False
self.verticalOff()
elif k == 'minus':
self.btnMinusPressed = False
self.verticalOff()
class Example(Frame):
def __init__(self, parent):
self.catFactors = {}
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
def initUI(self):
if hasattr(self, 'frame0'):
self.frame0.destroy()
self.initUIRoot()
self.initUIFrame()
def initUIRoot(self):
self.parent.title("集总模型")
self.pack(fill=BOTH, expand=1)
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
self.frame0 = Frame(self, relief=RAISED)
self.frame0.pack(fill=BOTH, expand=True)
fileMenu = Menu(menubar)
fileMenu.add_command(label=u"新建催化剂", command=self.onNewCata)
fileMenu.add_command(label=u"精确预测", command=self.onNewPre)
fileMenu.add_command(label=u"趋势预测", command=self.onNewGraph)
fileMenu.add_command(label=u"最优条件预测", command=self.onNewBest)
helpMenu = Menu(menubar)
helpMenu.add_command(label=u"关于", command=self.onHelp)
mainPageMenu = Menu(menubar)
mainPageMenu.add_command(label=u"主页", command=self.initUI)
menubar.add_cascade(label="主页", menu=mainPageMenu)
menubar.add_cascade(label="操作", menu=fileMenu)
menubar.add_cascade(label="帮助", menu=helpMenu)
def initUIFrame(self):
self.frame0.columnconfigure(0, pad=5, weight=1)
self.frame0.columnconfigure(1, pad=5, weight=1)
self.frame0.columnconfigure(2, pad=5, weight=1)
self.frame0.columnconfigure(3, pad=5, weight=1)
self.frame0.columnconfigure(4, pad=5, weight=1)
self.frame0.columnconfigure(5, pad=5, weight=1)
self.frame0.rowconfigure(0, pad=37)
self.frame0.rowconfigure(1, pad=7)
self.frame0.rowconfigure(2, pad=7, weight=1)
titleImg = ImageTk.PhotoImage(file="./imgs/title.png")
catImg = ImageTk.PhotoImage(file="./imgs/cat.png")
preImg = ImageTk.PhotoImage(file="./imgs/pre.png")
chartImg = ImageTk.PhotoImage(file="./imgs/chart.png")
bestImg = ImageTk.PhotoImage(file="./imgs/bestPoint.png")
rareImg = ImageTk.PhotoImage(file="./imgs/rare.png")
lbl = Label(self.frame0, image=titleImg)
lbl.grid(row=0, column=1,columnspan=5,sticky=S+W)
lbl.image = titleImg
lbl = Label(self.frame0, image=rareImg)
lbl.grid(row=3, column=1,columnspan=5,sticky=S)
lbl.image = rareImg
preButton = Button(self.frame0, command=self.onNewPre)
preButton.config(image=preImg)
preButton.image = preImg
preButton.grid(row=1, column=2)
cateButton = Button(self.frame0, command=self.onNewCata)
cateButton.config(image=catImg)
cateButton.image = catImg
cateButton.grid(row=1, column=1)
chartButton = Button(self.frame0, command=self.onNewGraph)
chartButton.config(image=chartImg)
chartButton.image = chartImg
chartButton.grid(row=1, column=3)
chartButton = Button(self.frame0, command=self.onNewBest)
chartButton.config(image=bestImg)
chartButton.image = bestImg
chartButton.grid(row=1, column=4)
lbl = Label(self.frame0, text="新建催化剂")
lbl.grid(row=2, column=1, sticky=N)
lbl = Label(self.frame0, text="精确预测")
lbl.grid(row=2, column=2, sticky=N)
lbl = Label(self.frame0, text="趋势预测")
lbl.grid(row=2, column=3, sticky=N)
lbl = Label(self.frame0, text="最优条件预测")
lbl.grid(row=2, column=4, sticky=N)
def bestUI(self):
self.frame0.destroy()
self.initUIRoot()
frame1 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame1.pack(fill=BOTH, expand=False)
frame2 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame2.pack(fill=BOTH, expand=True)
frame1.columnconfigure(1, weight=1)
# frame1.columnconfigure(9, weight=1)
frame1.columnconfigure(10, pad=7)
frame1.rowconfigure(5, weight=1)
frame1.rowconfigure(5, pad=7)
frame2.columnconfigure(11, pad=7, weight=1)
frame2.rowconfigure(8, pad=7)
lbl = Label(frame1, text="催化剂性质")
lbl.grid(row=0, column=0, columnspan=8, rowspan=1, sticky=W, pady=4, padx=5)
# K_Mat_Tree = ttk.Treeview(frame1)
# K_Mat_Tree['show'] = 'headings'
# K_Mat_Tree = self.makeMatrixUI(7, K_Mat_Tree, sourceDate.K_model)
# K_Mat_Tree.grid(row=1, column=0, columnspan=6, rowspan=5, sticky=E + W + S + N, pady=4, padx=5)
K_Mat_Tree = Text(frame1, height=18)
self.makeMatrixUI(K_Mat_Tree, self.catObj)
K_Mat_Tree.configure(state='normal')
K_Mat_Tree.grid(row=1, column=0, columnspan=6, rowspan=6, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="优化方法:")
lbl.grid(row=0, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.optMethod)
txt.configure(state='readonly')
txt.grid(row=0, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="集总数:")
lbl.grid(row=1, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.n)
txt.configure(state='readonly')
txt.grid(row=1, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="精确度:")
lbl.grid(row=2, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.tol)
txt.configure(state='readonly')
txt.grid(row=2, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
cateDetailButton = Button(frame1, text="查看催化剂详情")
cateDetailButton.grid(row=3, column=8)
# ________________________________________
lbl = Label(frame2, text="待预测条件")
lbl.grid(row=0, column=0, sticky=W, columnspan=5, rowspan=1, pady=4, padx=5)
lbl = Label(frame2, text="初始组成（<1 英文逗号分割）:")
lbl.grid(row=1, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.Y0_input = Entry(frame2)
self.Y0_input.grid(row=1, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="温度范围（K 英文逗号分割 ）")
lbl.grid(row=2, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.T_input = Entry(frame2)
if not self.catObj.withTemp:
self.T_input.insert(0, self.catObj.t)
self.T_input.configure(state='readonly')
self.T_input.grid(row=2, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="压力范围（KPa 英文逗号分割）")
lbl.grid(row=3, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.p_input = Entry(frame2)
self.p_input.grid(row=3, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="剂油比范围 （英文逗号分割）")
lbl.grid(row=4, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.roil_input = Entry(frame2)
self.roil_input.grid(row=4, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="停留时间范围（英文逗号分割s）")
lbl.grid(row=5, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.t_input = Entry(frame2)
self.t_input.grid(row=5, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="碱氮含量（<1）")
lbl.grid(row=6, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.yn_input = Entry(frame2)
self.yn_input.insert(0, 0.0)
self.yn_input.grid(row=6, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="重芳烃含量（<1）")
lbl.grid(row=7, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.ya_input = Entry(frame2)
self.ya_input.grid(row=7, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="微分方程步长")
lbl.grid(row=8, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.step_input = Entry(frame2)
self.step_input.insert(0, 0.1)
self.step_input.grid(row=8, column=2, columnspan=3, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="待预测组分编号（，）")
lbl.grid(row=9, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.target = Entry(frame2)
self.target.insert(0, '5,6,7')
self.target.grid(row=9, column=2, columnspan=3, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="结果组成")
lbl.grid(row=0, column=7, columnspan=2, rowspan=1, pady=4, padx=5, sticky=W)
self.preResult_LB = Listbox(frame2)
self.preResult_LB.grid(row=1, column=7, columnspan=2, rowspan=8, pady=4, padx=5, sticky=W)
lbl = Label(frame2, text="最优温度：")
lbl.grid(row=0, column=9, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.bestT = Entry(frame2)
self.bestT.delete(0, 'end')
self.bestT.configure(state='readonly')
self.bestT.grid(row=0, column=11, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="最优压力：")
lbl.grid(row=1, column=9, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.bestP = Entry(frame2)
self.bestP.delete(0, 'end')
self.bestP.configure(state='readonly')
self.bestP.grid(row=1, column=11, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="最优剂油比：")
lbl.grid(row=2, column=9, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.bestR = Entry(frame2)
self.bestR.delete(0, 'end')
self.bestR.configure(state='readonly')
self.bestR.grid(row=2, column=11, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="最优反应时间：")
lbl.grid(row=3, column=9, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.bestTime = Entry(frame2)
self.bestTime.delete(0, 'end')
self.bestTime.configure(state='readonly')
self.bestTime.grid(row=3, column=11, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="目标结果：")
lbl.grid(row=4, column=9, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.bestSum = Entry(frame2)
self.bestSum.delete(0, 'end')
self.bestSum.configure(state='readonly')
self.bestSum.grid(row=4, column=11, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
cateDetailButton = Button(frame2, text="预测", command=self.doBest)
cateDetailButton.grid(row=9, column=6, columnspan=2)
def preUI(self):
self.frame0.destroy()
self.initUIRoot()
frame1 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame1.pack(fill=BOTH, expand=False)
frame2 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame2.pack(fill=BOTH, expand=True)
frame1.columnconfigure(1, weight=1)
# frame1.columnconfigure(9, weight=1)
frame1.columnconfigure(10, pad=7)
frame1.rowconfigure(5, weight=1)
frame1.rowconfigure(5, pad=7)
frame2.columnconfigure(8, pad=7, weight=1)
frame2.rowconfigure(8, pad=7)
lbl = Label(frame1, text="催化剂性质")
lbl.grid(row=0, column=0, columnspan=8, rowspan=1, sticky=W, pady=4, padx=5)
# K_Mat_Tree = ttk.Treeview(frame1)
# K_Mat_Tree['show'] = 'headings'
# K_Mat_Tree = self.makeMatrixUI(7, K_Mat_Tree, sourceDate.K_model)
# K_Mat_Tree.grid(row=1, column=0, columnspan=6, rowspan=5, sticky=E + W + S + N, pady=4, padx=5)
K_Mat_Tree = Text(frame1, height=18)
self.makeMatrixUI(K_Mat_Tree, self.catObj)
K_Mat_Tree.configure(state='normal')
K_Mat_Tree.grid(row=1, column=0, columnspan=6, rowspan=6, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="优化方法:")
lbl.grid(row=0, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.optMethod)
txt.configure(state='readonly')
txt.grid(row=0, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="集总数:")
lbl.grid(row=1, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.n)
txt.configure(state='readonly')
txt.grid(row=1, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="精确度:")
lbl.grid(row=2, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.tol)
txt.configure(state='readonly')
txt.grid(row=2, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
cateDetailButton = Button(frame1, text="查看催化剂详情")
cateDetailButton.grid(row=3, column=8)
# ________________________________________
lbl = Label(frame2, text="待预测条件")
lbl.grid(row=0, column=0, sticky=W, columnspan=5, rowspan=1, pady=4, padx=5)
lbl = Label(frame2, text="初始组成（<1 英文逗号分割）:")
lbl.grid(row=1, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.Y0_input = Entry(frame2)
self.Y0_input.grid(row=1, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="温度（K）")
lbl.grid(row=2, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.T_input = Entry(frame2)
if not self.catObj.withTemp:
self.T_input.insert(0, self.catObj.t)
self.T_input.configure(state='readonly')
self.T_input.grid(row=2, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="压力（KPa）")
lbl.grid(row=3, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.p_input = Entry(frame2)
self.p_input.grid(row=3, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="剂油比")
lbl.grid(row=4, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.roil_input = Entry(frame2)
self.roil_input.grid(row=4, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="停留时间（s）")
lbl.grid(row=5, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.t_input = Entry(frame2)
self.t_input.grid(row=5, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="碱氮含量（<1）")
lbl.grid(row=6, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.yn_input = Entry(frame2)
self.yn_input.insert(0, 0.0)
self.yn_input.grid(row=6, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="重芳烃含量（<1）")
lbl.grid(row=7, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.ya_input = Entry(frame2)
self.ya_input.grid(row=7, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="微分方程步长")
lbl.grid(row=8, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.step_input = Entry(frame2)
self.step_input.insert(0, 0.1)
self.step_input.grid(row=8, column=2, columnspan=3, rowspan=1, sticky=E, pady=4, padx=5)
self.preResult_LB = Listbox(frame2)
self.preResult_LB.grid(row=1, column=7, columnspan=2, rowspan=6, pady=4, padx=5)
cateDetailButton = Button(frame2, text="预测", command=self.doPre)
cateDetailButton.grid(row=8, column=7, columnspan=2)
def cateUI(self):
self.frame0.destroy()
self.initUIRoot()
frame4 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame4.pack(fill=BOTH)
frame1 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame1.pack(fill=BOTH, expand=True)
frame1.columnconfigure(0, weight=1)
# frame1.columnconfigure(9, weight=1)
frame1.rowconfigure(0, weight=1)
lbl = Label(frame4, text="已输入温度组数")
lbl.grid(row=0, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.varCountT = StringVar()
self.countT = Message(frame4, textvariable=self.varCountT)
self.varCountT.set('0')
self.countT.grid(row=0, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
factor_Tree = ttk.Treeview(frame1)
factor_Tree['show'] = 'headings'
factor_Tree["columns"] = ['t_resid', 't', 'r_oil', 'p', 'Y0', 'Y_results', 'w_aro', 'w_nitro']
#
factor_Tree.heading("t", text="温度")
factor_Tree.column("t", width=self.winfo_width() / 8)
factor_Tree.heading("r_oil", text="剂油比")
factor_Tree.column("r_oil", width=self.winfo_width() / 8)
factor_Tree.heading("p", text="压力")
factor_Tree.column("p", width=self.winfo_width() / 8)
factor_Tree.heading("Y0", text="初始组成")
factor_Tree.column("Y0", width=self.winfo_width() / 8)
factor_Tree.heading("Y_results", text="产物组成")
factor_Tree.column("Y_results", width=self.winfo_width() / 8)
factor_Tree.heading("w_aro", text="重芳烃含量")
factor_Tree.column("w_aro", width=self.winfo_width() / 8)
factor_Tree.heading("w_nitro", text="碱氮含量")
factor_Tree.column("w_nitro", width=self.winfo_width() / 8)
factor_Tree.heading("t_resid", text="停留时间")
factor_Tree.column("t_resid", width=self.winfo_width() / 8)
factor_Tree.grid(row=0, column=0, pady=4, padx=5)
self.factor_Tree = factor_Tree
frame2 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame2.pack(fill=BOTH, expand=True)
frame2.columnconfigure(0, weight=1)
frame2.columnconfigure(8, weight=1)
lbl = Label(frame2, text="停留时间（s）")
lbl.grid(row=0, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.t_input = Entry(frame2)
self.t_input.grid(row=0, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="温度（K）")
lbl.grid(row=1, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.T_input = Entry(frame2)
self.T_input.grid(row=1, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="剂油比")
lbl.grid(row=2, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.roil_input = Entry(frame2)
self.roil_input.grid(row=2, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="压力（KPa）")
lbl.grid(row=3, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.p_input = Entry(frame2)
self.p_input.grid(row=3, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="初始组成（<1 英文逗号分割）:")
lbl.grid(row=0, column=4, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.Y0_input = Entry(frame2)
self.Y0_input.grid(row=0, column=6, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="产物组成（<1 英文逗号分割）:")
lbl.grid(row=1, column=4, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.Y_results_input = Entry(frame2)
self.Y_results_input.grid(row=1, column=6, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="碱氮含量（<1）")
lbl.grid(row=2, column=4, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.yn_input = Entry(frame2)
self.yn_input.insert(0, 0.0)
self.yn_input.grid(row=2, column=6, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="重芳烃含量（<1）")
lbl.grid(row=3, column=4, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.ya_input = Entry(frame2)
self.ya_input.grid(row=3, column=6, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="分子质量（逗号分割）")
lbl.grid(row=4, column=4, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.Molmasses_input = Entry(frame2)
self.Molmasses_input.grid(row=4, column=6, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.Molmasses_input.insert('0.8,1.1,1.8,0.2,0.2,0.2,0.11,0.016,0.042,0.056,0.05,0.012')
addButton = Button(frame2, command=self.addFactors, text="添加条件")
addButton.grid(row=9, column=2, sticky=E)
self.newCatButton = Button(frame2, command=self.newCata, text="开始计算", state=DISABLED)
self.newCatButton.grid(row=9, column=6, sticky=E)
def graphUI(self):
self.frame0.destroy()
self.initUIRoot()
frame1 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame1.pack(fill=BOTH, expand=False)
frame2 = Frame(self.frame0, relief=RAISED, borderwidth=1)
frame2.pack(fill=BOTH, expand=True)
frame1.columnconfigure(1, weight=1)
# frame1.columnconfigure(9, weight=1)
frame1.columnconfigure(10, pad=7)
frame1.rowconfigure(5, weight=1)
frame1.rowconfigure(5, pad=7)
frame2.columnconfigure(8, pad=7, weight=1)
frame2.columnconfigure(1, weight=1)
frame2.columnconfigure(6, weight=1)
frame2.rowconfigure(8, pad=7)
lbl = Label(frame1, text="催化剂性质")
lbl.grid(row=0, column=0, columnspan=8, rowspan=1, sticky=W, pady=4, padx=5)
# K_Mat_Tree = ttk.Treeview(frame1)
# K_Mat_Tree['show'] = 'headings'
# K_Mat_Tree = self.makeMatrixUI(7, K_Mat_Tree, sourceDate.K_model)
# K_Mat_Tree.grid(row=1, column=0, columnspan=6, rowspan=5, sticky=E + W + S + N, pady=4, padx=5)
K_Mat_Tree = Text(frame1, height=18)
self.makeMatrixUI(K_Mat_Tree, self.catObj)
K_Mat_Tree.configure(state='normal')
K_Mat_Tree.grid(row=1, column=0, columnspan=6, rowspan=6, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="优化方法:")
lbl.grid(row=0, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.optMethod)
txt.configure(state='readonly')
txt.grid(row=0, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="集总数:")
lbl.grid(row=1, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.n)
txt.configure(state='readonly')
txt.grid(row=1, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
lbl = Label(frame1, text="精确度:")
lbl.grid(row=2, column=6, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
txt = Entry(frame1)
txt.insert(0, self.catObj.tol)
txt.configure(state='readonly')
txt.grid(row=2, column=8, columnspan=2, rowspan=1, sticky=E + W + S + N, pady=4, padx=5)
cateDetailButton = Button(frame1, text="查看催化剂详情")
cateDetailButton.grid(row=3, column=8)
# ________________________________________
lbl = Label(frame2, text="待预测条件")
lbl.grid(row=0, column=0, columnspan=5, rowspan=1, pady=4, padx=5)
lbl = Label(frame2, text="初始组成（<1 英文逗号分割）:")
lbl.grid(row=1, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.Y0_input = Entry(frame2)
self.Y0_input.grid(row=1, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="温度（K）")
lbl.grid(row=2, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.T_input = Entry(frame2)
self.T_input.grid(row=2, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="压力（KPa）")
lbl.grid(row=3, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.p_input = Entry(frame2)
self.p_input.grid(row=3, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="剂油比")
lbl.grid(row=4, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.roil_input = Entry(frame2)
self.roil_input.grid(row=4, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="停留时间（s）")
lbl.grid(row=5, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.t_input = Entry(frame2)
self.t_input.grid(row=5, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="碱氮含量（<1）")
lbl.grid(row=6, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.yn_input = Entry(frame2)
self.yn_input.insert(0, 0.0)
self.yn_input.grid(row=6, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="重芳烃含量（<1）")
lbl.grid(row=7, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.ya_input = Entry(frame2)
self.ya_input.grid(row=7, column=2, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="微分方程步长")
lbl.grid(row=8, column=0, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.step_input = Entry(frame2)
self.step_input.insert(0, 0.1)
self.step_input.grid(row=8, column=2, columnspan=3, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="图表设置")
lbl.grid(row=0, column=6, columnspan=5, rowspan=1, pady=4, padx=5)
lbl = Label(frame2, text="条件变量")
lbl.grid(row=1, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.var = ttk.Combobox(frame2, textvariable=StringVar())
if not self.catObj.withTemp:
self.var['values'] = (u'压力', u'剂油比', u'停留时间')
self.p_input.insert(0, 0)
self.T_input.insert(0, self.catObj.t)
self.T_input.configure(state='readonly')
self.p_input.configure(state='readonly')
self.lastVar = u'压力'
else:
self.T_input.delete(0, 'end')
self.T_input.insert(0, 0)
self.T_input.configure(state='readonly')
self.var['values'] = (u'温度', u'压力', u'剂油比', u'停留时间', u'温度+压力',u'温度+剂油比',u'剂油比+压力')
self.lastVar = u'温度'
self.var.bind('<<ComboboxSelected>>', self.onSelecetedVar)
self.var.current(0)
self.var.grid(row=1, column=8, columnspan=2, rowspan=1, sticky=W, pady=4, padx=5)
self.rangeLbl = Label(frame2, text="条件范围")
self.rangeLbl.grid(row=2, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="上限")
lbl.grid(row=3, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
lbl = Label(frame2, text="下限")
lbl.grid(row=4, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.rangeMin = Entry(frame2)
self.rangeMax = Entry(frame2)
self.rangeMin.grid(row=3, column=8, columnspan=1, sticky=W, rowspan=1, pady=4, padx=5)
self.rangeMax.grid(row=4, column=8, columnspan=1, sticky=W, rowspan=1, pady=4, padx=5)
lbl = Label(frame2, text="结果集（英文逗号分割）")
lbl.grid(row=5, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.chartResultId = Entry(frame2)
self.chartResultId.insert(0, '1,2,3,4,5,6,7,8,9,10,11,12')
self.chartResultId.grid(row=5, column=8, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="结果名（英文逗号分割\n尽量使用英文）")
lbl.grid(row=6, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.chartResultName = Entry(frame2)
#TODO,get the default value from lump model
self.chartResultName.insert(0, 'HS,HA,HR,DIESEL,GS,GO,GA,DGAS,LO3,LO4,LPGD,COKE')
self.chartResultName.grid(row=6, column=8, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
lbl = Label(frame2, text="点数")
lbl.grid(row=7, column=6, columnspan=2, rowspan=1, sticky=E, pady=4, padx=5)
self.stepNum = Entry(frame2)
self.stepNum.grid(row=7, column=8, columnspan=3, rowspan=1, sticky=W, pady=4, padx=5)
cateDetailButton = Button(frame2, text="预测趋势", command=self.doChart)
cateDetailButton.grid(row=8, column=6, columnspan=2)
def onSelecetedVar(self, event):
varName = self.var.get()
if self.lastVar == u'温度':
# u'温度',,,u'停留时间'
self.T_input.configure(state="normal")
elif self.lastVar == u'压力':
self.p_input.configure(state="normal")
elif self.lastVar == u'剂油比':
self.roil_input.configure(state="normal")
elif self.lastVar == u'停留时间':
self.t_input.configure(state="normal")
elif self.lastVar == u'温度+压力':
self.T_input.configure(state="normal")
self.p_input.configure(state="normal")
elif self.lastVar == u'温度+剂油比':
self.roil_input.configure(state="normal")
self.T_input.configure(state="normal")
elif self.lastVar == u'剂油比+压力':
self.roil_input.configure(state="normal")
self.p_input.configure(state="normal")
if varName == u'温度':
self.rangeLbl.config(text='条件范围')
self.T_input.delete(0, 'end')
self.T_input.insert(0, 0)
self.T_input.configure(state="readonly")
elif varName == u'压力':
self.rangeLbl.config(text='条件范围')
self.p_input.delete(0, 'end')
self.p_input.insert(0, 0)
self.p_input.configure(state="readonly")
elif varName == u'剂油比':
self.rangeLbl.config(text='条件范围')
self.roil_input.delete(0, 'end')
self.roil_input.insert(0, 0)
self.roil_input.configure(state="readonly")
elif varName == u'停留时间':
self.rangeLbl.config(text='条件范围')
self.t_input.delete(0, 'end')
self.t_input.insert(0, 0)
self.t_input.configure(state="readonly")
elif varName == u'温度+压力':
self.rangeLbl.config(text='条件范围,格式：温度，压力')
self.T_input.delete(0, 'end')
self.T_input.insert(0, 0)
self.T_input.configure(state="readonly")
self.p_input.delete(0, 'end')
self.p_input.insert(0, 0)
self.p_input.configure(state="readonly")
elif varName == u'温度+剂油比':
self.rangeLbl.config(text='条件范围,格式：温度，剂油比')
self.roil_input.delete(0, 'end')
self.roil_input.insert(0, 0)
self.roil_input.configure(state="readonly")
self.T_input.delete(0, 'end')
self.T_input.insert(0, 0)
self.T_input.configure(state="readonly")
elif varName == u'剂油比+压力':
self.rangeLbl.config(text='条件范围,格式：剂油比，压力')
self.roil_input.delete(0, 'end')
self.roil_input.insert(0, 0)
self.roil_input.configure(state="readonly")
self.p_input.delete(0, 'end')
self.p_input.insert(0, 0)
self.p_input.configure(state="readonly")
self.lastVar = varName
def onNewCata(self):
self.catFactors = {}
ftypes = [('集总模型', '*.lp')]
dlg = tkFileDialog.Open(self, filetypes=ftypes)
fl = dlg.show()
# print flmakePreResultUI
if fl != '':
self.lumpObj = self.readFile(fl)
print self.lumpObj
self.cateUI()
def onNewPre(self):
ftypes = [('催化剂存档文件', '*.cat')]
dlg = tkFileDialog.Open(self, filetypes=ftypes)
fl = dlg.show()
print fl
if fl != '':
self.catObj = self.readFile(fl)
self.preUI()
def onNewBest(self):
ftypes = [('催化剂存档文件', '*.cat')]
dlg = tkFileDialog.Open(self, filetypes=ftypes)
fl = dlg.show()
print fl
if fl != '':
self.catObj = self.readFile(fl)
self.bestUI()
def onNewGraph(self):
ftypes = [('催化剂存档文件', '*.cat')]
dlg = tkFileDialog.Open(self, filetypes=ftypes)
fl = dlg.show()
print fl
if fl != '':
self.catObj = self.readFile(fl)
self.graphUI()
def saveCate(self):
ftypes = [('催化剂存档文件', '*.cat')]
filename = tkFileDialog.asksaveasfilename(title='保存催化剂存档文件', defaultextension='.cat', filetypes=ftypes)
return filename
def onHelp(self):
mbox.showinfo("集总模型软件", "中国石油\n兰州化工研究中心")
def doPre(self):
catObj = self.catObj
t_resid = float(self.t_input.get())
p = float(self.p_input.get())
Y0 = numpy.mat(self.Y0_input.get().split(',')).astype(numpy.float)
const_r = 8.3145
w_aro = float(self.ya_input.get())
w_nitro = float(self.yn_input.get())
t = float(self.T_input.get())
r_oil = float(self.roil_input.get())
stepLength = float(self.step_input.get())
n = catObj.n
print [t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n]
result = newPre(catObj, t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n, stepLength).tolist()[0]
self.makePreResultUI(self.preResult_LB, result)
def doBest(self):
catObj = self.catObj
t_resid = [float(self.t_input.get().split(',')[0]),float(self.t_input.get().split(',')[1])]
p = [float(self.p_input.get().split(',')[0]),float(self.p_input.get().split(',')[1])]
Y0 = numpy.mat(self.Y0_input.get().split(',')).astype(numpy.float)
const_r = 8.3145
w_aro = float(self.ya_input.get())
w_nitro = float(self.yn_input.get())
t = [float(self.T_input.get().split(',')[0]),float(self.T_input.get().split(',')[1])]
r_oil = [float(self.roil_input.get().split(',')[0]),float(self.roil_input.get().split(',')[1])]
stepLength = float(self.step_input.get())
n = catObj.n
target = self.target.get().split(',')
print [t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n,target]
result = newBest(catObj, t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n, stepLength,target)
self.bestP.configure(state='normal')
self.bestT.configure(state='normal')
self.bestR.configure(state='normal')
self.bestTime.configure(state='normal')
self.bestSum.configure(state='normal')
self.bestP.insert('end',round(result['bestP'], 4))
self.bestT.insert('end',round(result['bestT'], 4))
self.bestR.insert('end',round(result['bestR'], 4))
self.bestTime.insert('end',round(result['bestTime'], 4))
self.bestSum.insert('end',round(result['sum'], 4))
self.makePreResultUI(self.preResult_LB, result['Y'])
def doChart(self):
catObj = self.catObj
t_resid = float(self.t_input.get())
p = float(self.p_input.get())
Y0 = numpy.mat(self.Y0_input.get().split(',')).astype(numpy.float)
const_r = 8.3145
w_aro = float(self.ya_input.get())
w_nitro = float(self.yn_input.get())
t = float(self.T_input.get())
r_oil = float(self.roil_input.get())
stepNum = int(self.stepNum.get())
resultId = self.chartResultId.get()
resultName = self.chartResultName.get()
stepLength = float(self.step_input.get())
n = catObj.n
varName = ''
if self.lastVar == u'温度':
varName = 't'
varMin = float(self.rangeMin.get())
varMax = float(self.rangeMax.get())
elif self.lastVar == u'压力':
varName = 'p'
varMin = float(self.rangeMin.get())
varMax = float(self.rangeMax.get())
elif self.lastVar == u'剂油比':
varName = 'r'
varMin = float(self.rangeMin.get())
varMax = float(self.rangeMax.get())
elif self.lastVar == u'停留时间':
varName = 'time'
varMin = float(self.rangeMin.get())
varMax = float(self.rangeMax.get())
elif self.lastVar == u'温度+压力':
varName = 't,p'.split(',')
varMin = self.rangeMin.get().split(',')
varMax = self.rangeMax.get().split(',')
elif self.lastVar == u'温度+剂油比':
varName = 't,r'.split(',')
varMin = self.rangeMin.get().split(',')
varMax = self.rangeMax.get().split(',')
elif self.lastVar == u'剂油比+压力':
varName = 'r,p'.split(',')
varMin = self.rangeMin.get().split(',')
varMax = self.rangeMax.get().split(',')
chartConfig = {}
chartConfig['varName'] = varName
chartConfig['stepNum'] = stepNum
chartConfig['varMin'] = varMin
chartConfig['varMax'] = varMax
chartConfig['resultId'] = resultId
chartConfig['resultName'] = resultName
# t_resid=3
# p=175
# const_r=8.3145
# Y0=mat([0.481,0.472,0.047,0,0,0,0])
# w_aro=0.472
# w_nitro=0
# t=685
# n=7
# r_oil=8.79
# chartConfig={'varName': 'time', 'varMax': 0.001, 'varMin': 15.0, 'resultId': '1,2,3,4,5,6,7', 'stepNum': 100,'resultName':u'Hs,Ha,Hr,柴油,汽油,气体,焦炭'}
print chartConfig
print [catObj, t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n, chartConfig]
if len(varName)>1:
result = new3dChart(catObj, t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n, chartConfig, stepLength)
else:
result = new2dChart(catObj, t_resid, p, Y0, const_r, w_aro, w_nitro, t, r_oil, n, chartConfig, stepLength)
def addFactors(self):
t_resid = float(self.t_input.get())
p = float(self.p_input.get())
Y0_raw = self.Y0_input.get()
Y0 = numpy.mat(Y0_raw.split(',')).astype(numpy.float)
Y_results_raw = self.Y_results_input.get()
Y_results = numpy.mat(Y_results_raw.split(',')).astype(numpy.float)
w_aro = float(self.ya_input.get())
w_nitro = float(self.yn_input.get())
t = float(self.T_input.get())
r_oil = float(self.roil_input.get())
self.Molmasses = numpy.mat(self.Molmasses_input.get().split(',')).astype(numpy.float)
self.factor_Tree.insert('', END, values=[t_resid, t, r_oil, p, Y0_raw, Y_results_raw, w_aro, w_nitro])
if self.catFactors.has_key(t):
self.catFactors[t].append(
{'t_resid': t_resid, 't': t, 'r_oil': r_oil, 'p': p, 'Y0': Y0, 'Y_results': Y_results, 'w_aro': w_aro,
'w_nitro': w_nitro})
else:
self.catFactors[t] = [
{'t_resid': t_resid, 't': t, 'r_oil': r_oil, 'p': p, 'Y0': Y0, 'Y_results': Y_results, 'w_aro': w_aro,
'w_nitro': w_nitro}]
print self.catFactors
self.varCountT.set(len(self.catFactors))
self.Molmasses_input.configure(state='readonly')
self.newCatButton.configure(state='active')
def newCata(self):
filename = self.saveCate()
print filename
if len(self.catFactors) == 1:
newCatNoKa(filename, self.lumpObj, 1, 0, 1, self.lumpObj, self.Molmasses, self.catFactors.values()[0],
'L-BFGS-B',
1e-5, self.lumpObj.shape[0])
else:
newCatWithKa(filename, self.lumpObj, 1, 0, 1, self.lumpObj, self.Molmasses, self.catFactors, 'L-BFGS-B',
1e-5,
self.lumpObj.shape[0])
def makeMatrixUI(self, targetTree, catObj):
n = catObj.n
if not catObj.withTemp:
targetTree.insert('end', '催化剂模型是在同一温度下，只能计算K\n------------------\nK=\n')
K = numpy.around(self.makeMatrixByResult(catObj.K_model, catObj.X0_result, catObj.n)['K_result'], 4)
self.makeMatrixOutput(n, targetTree, K)
targetTree.insert('end', '\n------------------\n重芳烃影响因数：\n')
targetTree.insert('end', self.makeMatrixByResult(catObj.K_model, catObj.X0_result, catObj.n)['Ka'])
targetTree.insert('end', '\n------------------\n碱氮影响因数：\n')
targetTree.insert('end', self.makeMatrixByResult(catObj.K_model, catObj.X0_result, catObj.n)['Kn'])
targetTree.insert('end', '\n------------------\n')
else:
K = self.makeMatrixByResult(catObj.K_model, catObj.X0_result, catObj.n)['K_result']
print catObj.X0_result
Ka = numpy.around(self.makeMatrixByResult(catObj.K_model, catObj.Ka, catObj.n)['K_result'], 4)
print catObj.Ka
Ea = numpy.around(self.makeMatrixByResult(catObj.K_model, catObj.Ea, catObj.n)['K_result'], 4)
print catObj.Ea
targetTree.insert('end', '\n------------------\nK=\n')
print len(K)
for i in K:
self.makeMatrixOutput(n, targetTree, numpy.round(i, 4))
targetTree.insert('end', '\n------------------\n')
targetTree.insert('end', '\n------------------\nKa=\n')
self.makeMatrixOutput(n, targetTree, Ka)
targetTree.insert('end', '\n------------------\n')
targetTree.insert('end', '\n------------------\nEa=\n')
self.makeMatrixOutput(n, targetTree, Ea)
targetTree.insert('end', '\n------------------\n')
def makeMatrixOutput(self, n, targetTree, mat):
for i in range(n):
targetTree.insert('end', ','.join(mat[i].astype(numpy.string_).tolist()))
targetTree.insert('end', '\n')
return targetTree
def makeMatrixByResult(self, K_model, result, n):
if type(result) != type([]):
K = result[:-3].tolist()
args = result[-3:]
K_raw_result = []
for i in K_model.T.flat:
if i:
K_raw_result.append(K.pop(0))
else:
K_raw_result.append(0)
K_result = reshape(K_raw_result, (n, n)).T.T.T
ka_result, kn_result, cata_result = args
return {'K_result': K_result, 'ka_result': ka_result, 'kn_result': kn_result, 'cata_result': cata_result}
else:
K_results = []
args = result[0][-3:]
for i in result:
K = i[:-3].tolist()
K_raw_result = []
for i in K_model.T.flat:
if i:
K_raw_result.append(K.pop(0))
else:
K_raw_result.append(0)
K_result = reshape(K_raw_result, (n, n)).T.T.T
K_results.append(K_result)
ka_result, kn_result, cata_result = args
return {'K_result': K_results, 'ka_result': ka_result, 'kn_result': kn_result,
'cata_result': cata_result}
def makePreResultUI(self, target, result):
target.delete(0, END)
if type(result)!=type([]):
result=result.tolist()[0]
for i in result:
target.insert(END, round(i, 3))
return target
def readFile(self, filename):
f = open(filename, "r")
obj = pickle.load(f)
return obj
class SettingsFrame(BasePAFrame):
"""
фрейм с параметрами
"""
def __init__(self, *args, **kwargs):
BasePAFrame.__init__(self, *args, **kwargs)
self.current_file = {}
self.last_move_path = settings.BASE_CATALOG
self.widgets = OrderedDict(
(label,
{
'label': Label(self, text=label),
'label_data': Label(self)
})
for label in LABELS)
# виджеты для преименований
self.widgets_with_rename = OrderedDict(
(label,
{
'label': Label(self, text=label),
'label_data': Label(self)
})
for label in LABELS_RENAME)
# переименование с моим именем
self.w_entry_custom_name = Entry(self)
self.w_btn_rename_custom_name = Button(self, text=u'Переименовать')
self.w_btn_rename_custom_name.bind(
'<Button-1>', self.click_rename_button)
self.widgets_with_rename[TEXT_MY_NAME] = {
'label': Label(self, text=TEXT_MY_NAME),
'label_data': self.w_entry_custom_name,
'button_rename': self.w_btn_rename_custom_name,
}
# доп кнопки, переместить удалить
_btn_mv = Button(self, text=u'Переместить')
_btn_mv.bind('<Button-1>', self.click_move_button)
_btn_rm = Button(self, text=u'Удалить')
_btn_rm.bind('<Button-1>', self.click_remove_button)
self.buttons = (
(_btn_mv, _btn_rm),
)
# прописываем кнопки переместить
for label, label_widgets in self.widgets_with_rename.iteritems():
if label in LABELS_RENAME:
_btn = Button(self, text=u'Переименовать')
_btn.bind('<Button-1>', self.click_rename_button)
_btn.meta = {}
label_widgets['button_rename'] = _btn
def _pa_layout(self):
BasePAFrame._pa_layout(self)
for index, labels in enumerate(self.widgets.values()):
labels['label'].grid(row=index, column=0)
labels['label_data'].grid(row=index, column=1)
for index, labels in enumerate(
self.widgets_with_rename.values(), index+1):
labels['label'].grid(row=index, column=0)
labels['label_data'].grid(row=index, column=1)
labels['button_rename'].grid(row=index, column=2)
for row, btns in enumerate(self.buttons, index+1):
for col, btn in enumerate(btns):
btn.grid(row=row, column=col)
def set_file(self, file_path, image):
stat = os.stat(file_path)
self.current_file['file_path'] = file_path
self.current_file['size'] = stat.st_size
date_create = datetime.datetime.fromtimestamp(stat.st_ctime)
date_modify = datetime.datetime.fromtimestamp(stat.st_mtime)
date_access = datetime.datetime.fromtimestamp(stat.st_atime)
try:
exif_data = image._getexif()
except AttributeError:
exif_data = None
if not exif_data:
exif_data = {
EXIF_TAGS_REVERSE['DateTimeOriginal']: u'n/d',
EXIF_TAGS_REVERSE['DateTimeDigitized']: u'n/d',
EXIF_TAGS_REVERSE['DateTime']: u'n/d',
}
self.widgets[TEXT_FILE_PATH]['label_data']['text'] = (
self.current_file['file_path'])
self.widgets[TEXT_IMAGE_SIZE]['label_data']['text'] = (
u'{0} / {1}'.format(*(image.size if image else (0, 0))))
self.widgets[TEXT_SIZE]['label_data']['text'] = (
u'{1} МБ / {0} Б'.format(
self.current_file['size'],
round(stat.st_size / 1024.0 / 1024, 2))
)
bind_maps = (
(TEXT_DATE_CREATE, date_create.strftime(settings.DATE_TIME_FORMAT)),
(TEXT_DATE_MODIFY, date_modify.strftime(settings.DATE_TIME_FORMAT)),
(TEXT_DATE_ACCESS, date_access.strftime(settings.DATE_TIME_FORMAT)),
(TEXT_EXIF_DATE_ORIGINAL,
exif_data.get(EXIF_TAGS_REVERSE['DateTimeOriginal'], u'n/a')),
(TEXT_EXIF_DATE_DIGITIZED,
exif_data.get(EXIF_TAGS_REVERSE['DateTimeDigitized'], u'n/a')),
(TEXT_EXIF_DATE_TIME,
exif_data.get(EXIF_TAGS_REVERSE['DateTime'], u'n/a')),
)
for text, data in bind_maps:
self.widgets_with_rename[text]['label_data'].config(text=data)
self.widgets_with_rename[text]['button_rename'].meta['data'] = data
def reset(self):
self.current_file = {}
def click_rename_button(self, event):
if not self.current_file:
return
if event.widget == self.w_btn_rename_custom_name:
data = self.w_entry_custom_name.get()
re_suffix = "re"
if data.startswith(re_suffix):
_, re_template, replacer = data.split("|")
file_name = os.path.basename(self.current_file['file_path'])
finds = re.findall(re_template, file_name)[0]
data = replacer.format(*finds)
else:
self.w_entry_custom_name.delete(0, END)
else:
meta = event.widget.meta
if not meta:
return
try:
date = datetime.datetime.strptime(
meta['data'], settings.DATE_TIME_FORMAT)
except ValueError:
try:
date = datetime.datetime.strptime(
meta['data'], settings.DATE_TIME_FORMAT_EXIF)
except ValueError:
return
data = date.strftime(date_format)
new_file_name = (
u'{0} {1}{2}'.format(
data,
self.current_file['size'],
os.path.splitext(self.current_file['file_path'])[-1]))
new_file_dir = os.path.dirname(self.current_file['file_path'])
new_file_path = os.path.join(new_file_dir, new_file_name)
if new_file_path != self.current_file['file_path']:
if os.path.exists(new_file_path):
showerror(
u'Ошибка',
u'Файл ({0}) уже существует, '
u'переименовать невозможно'.format(new_file_path))
else:
os.rename(self.current_file['file_path'], new_file_path)
self.master.handle_update_files()
def click_move_button(self, event):
"""
переместить файл
:param event:
:return:
"""
if self.current_file:
path = askdirectory(
title=u'Выберите папку для перемещения',
initialdir=self.last_move_path)
if not path:
return
self.last_move_path = path
src = self.current_file['file_path']
file_name = os.path.basename(src)
dst = os.path.join(path, file_name)
os.rename(src, dst)
self.master.reset()
self.master.handle_update_files()
def click_remove_button(self, event):
# error, info, question, or warning
if askyesno(
u'Удалить файл?',
self.current_file['file_path'],
icon='warning'):
os.remove(self.current_file['file_path'])
self.master.reset()
self.master.handle_update_files()
class Login():
def __init__(self, parent):
self.parent = parent
self.root = Tk()
self.db = SpellingDatabase()
self.loginFrame = Frame(self.root)
self.loginFrame.pack()
self.userEntry = Entry(self.loginFrame, width=15)
self.passEntry = Entry(self.loginFrame, width=15, show='*')
userLabel = Label(self.loginFrame, text="Username:"******"Password:"******"Login", command=self.login)
buttonRegSwitch = Button(self.loginFrame, text="New User",
command=self.viewRegister)
userLabel.grid(row=0, column=0)
self.userEntry.grid(row=0, column=1)
passLabel.grid(row=1, column=0)
self.passEntry.grid(row=1, column=1)
buttonSubmit.grid(row=2, column=1)
buttonRegSwitch.grid(row=2, column=0, padx=10)
self.registerFrame = Frame(self.root)
self.userRegEntry = Entry(self.registerFrame, width=15)
self.passRegEntry = Entry(self.registerFrame, width=15, show='*')
userRegLabel = Label(self.registerFrame, text="Username:"******"Password:"******"Register",
command=self.register)
buttonBack = Button(self.registerFrame, text="Back",
command=self.viewLogin)
userRegLabel.grid(row=0, column=0)
self.userRegEntry.grid(row=0, column=1)
passRegLabel.grid(row=1, column=0)
self.passRegEntry.grid(row=1, column=1)
buttonBack.grid(row=2, column=1)
buttonRegister.grid(row=2, column=0, padx=10)
self.root.mainloop()
def login(self):
usernameGiven = self.userEntry.get()
passwordGiven = self.passEntry.get()
userDetails = self.db.sql("""SELECT * FROM
users WHERE username='******'"""
%(usernameGiven.lower().strip()))
if len(userDetails)==1:
passHash = userDetails[0][2]
if (hashlib.sha1(passwordGiven).hexdigest() == passHash):
self.root.destroy()
self.parent.setUser(User(userDetails[0]))
else:
print 'Invalid Username or Password'
self.userEntry.delete(0, END)
self.passEntry.delete(0, END)
def register(self):
username = self.userRegEntry.get()
passwd = self.passRegEntry.get()
if username != '' and passwd != '':
username = username.lower().strip()
passHash = hashlib.sha1(passwd).hexdigest()
self.db.sql("""INSERT INTO users (username, passwd) VALUES
('%s', '%s')"""%(username, passHash))
self.viewLogin()
def viewRegister(self):
self.loginFrame.pack_forget()
self.registerFrame.pack()
def viewLogin(self):
self.registerFrame.pack_forget()
self.loginFrame.pack()
class Master:
def __init__(self, master):
self.master = master
master.title("HTTP FLOOD")
self.IP = None
self.message = "Type IP to be attacked:"
self.label_text = StringVar()
self.label_text.set(self.message)
self.label = Label(master, textvariable=self.label_text)
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master,
validate="key",
validatecommand=(vcmd, '%P'))
self.atack_button = Button(master,
text="Start Atack",
command=self.validate_IP)
self.stop_button = Button(master,
text="Stop Atack",
command=self.reset,
state=DISABLED)
self.label.grid(row=0, column=0, columnspan=2, sticky=W + E)
self.entry.grid(row=1, column=0, columnspan=2, sticky=W + E)
self.atack_button.grid(row=2, column=0)
self.stop_button.grid(row=2, column=1)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.IP = None
return True
else:
IP = new_text
self.IP = IP
return True
def validate_IP(self):
if (is_valid_ipv4(str(self.IP))):
self.message = "Valid IP, Contacting Slaves!"
self.atack_button.configure(state=DISABLED)
self.stop_button.configure(state=NORMAL)
else:
self.message = "Invalid IP, Try Again"
if self.IP is None:
self.message = "Type IP to be attacked:"
self.label_text.set(self.message)
def reset(self):
self.entry.delete(0, END)
self.IP = None
self.message = "Type IP to be attacked:"
self.label_text.set(self.message)
self.atack_button.configure(state=NORMAL)
self.stop_button.configure(state=DISABLED)
class View:
def __init__(self, master):
self.master = master
self.master.title("Naive Bayes Classifier")
Label(master, text="").grid(row=0)
self.dirPath = Label(master, text="Directory Path:").grid(row=1)
self.dirTextBox = Entry(master, width=60)
self.dirTextBox.grid(row=1, column=1)
self.browseButton = Button(master,
text="Browse",
command=lambda: self.browse())
self.browseButton.grid(row=1, column=3)
self.discBins = Label(master, text="Discretization Bins:").grid(row=2)
self.discBinsBox = Entry(master, width=60)
self.discBinsBox.grid(row=2, column=1)
self.buildButton = Button(master,
width=30,
text="Build",
command=lambda: self.build())
self.buildButton.grid(row=4, column=1)
self.classifyButton = Button(master,
width=30,
text="Classify",
command=lambda: self.classify())
self.classifyButton.grid(row=5, column=1)
root.mainloop()
def browse(self):
self.dirPath = tkFileDialog.askdirectory()
if self.isRequestedFilesExist():
self.dirTextBox.delete(0, len(self.dirTextBox.get()))
self.dirTextBox.insert(0, self.dirPath)
else:
tkMessageBox.showerror(
"Naive Bayes Classifier - Error",
"This path - doesn't contain the requested files.")
def isRequestedFilesExist(self):
expfiles = ["Structure.txt", "train.csv", "test.csv"]
for path, subdirs, files in os.walk(self.dirPath):
for name in files:
if name.startswith("Structure.txt"):
expfiles.remove("Structure.txt")
elif name.startswith("train.csv"):
expfiles.remove("train.csv")
elif name.startswith("test.csv"):
expfiles.remove("test.csv")
if len(expfiles) > 0:
self.buildButton.config(state='disabled')
return False
else:
self.buildButton.config(state='normal')
return True
def isBinsNumberReal(self):
try:
int(self.binsNum)
return True
except:
return False
def build(self):
if self.dirTextBox.get() == None or self.dirTextBox.get() == "":
tkMessageBox.showerror("Naive Bayes Classifier - Error",
"There is no path.")
else:
self.dirPath = self.dirTextBox.get()
self.binsNum = self.discBinsBox.get()
if not self.isRequestedFilesExist():
tkMessageBox.showerror(
"Naive Bayes Classifier - Error",
"This path - doesn't contain the requested files.")
elif not self.isBinsNumberReal():
tkMessageBox.showerror("Naive Bayes Classifier - Error",
"This bins number is illegal.")
elif self.isDataEmpty():
tkMessageBox.showerror("Naive Bayes Classifier - Error",
"This is an Empty File of Train.")
else:
tkMessageBox.showinfo(
"Naive Bayes Classifier",
"Build is going to start after you click agree. \n"
"It may takes a few minutes and the messageBox going to be unable and black untill it's done."
)
self.binsNum = int(self.discBinsBox.get())
self.loadTrainSet()
def classify(self):
if not self.isRequestedFilesExist():
tkMessageBox.showerror(
"Naive Bayes Classifier - Error",
"This path - doesn't contain the requested files.")
else:
self.classifier.classify()
tkMessageBox.showinfo("Naive Bayes Classifier - Success",
"Classified. Check out the output.txt")
sys.exit()
def loadTrainSet(self):
self.classifier = Classifier(self.dirPath, self.binsNum)
def isDataEmpty(self):
if (os.stat(self.dirPath + "/train.csv").st_size > 3):
return False
else:
return True
class ServerAddressView:
def __init__(self, container, application):
self.container = container
self.application = application
# LEFT CONTAINER
self.frame_left = Frame(container)
self.frame_left.pack(side=LEFT, padx=20, pady=20)
exchange_label = Label(self.frame_left, text="Server info")
exchange_label.pack(side=TOP, pady=10)
# Exchange name row
frame_row1 = Frame(self.frame_left)
frame_row1.pack(side=TOP, padx=20, pady=5)
exchange_label = Label(frame_row1, text="Name:")
exchange_label.pack(side=LEFT)
self.exchangeEntry = Entry(frame_row1, bd=5)
self.exchangeEntry.pack(side=LEFT)
# Hostname row
frame_row2 = Frame(self.frame_left)
frame_row2.pack(side=TOP, padx=20, pady=5)
host_label = Label(frame_row2, text="Host: ")
host_label.pack(side=LEFT)
self.hostEntry = Entry(frame_row2, bd=5)
self.hostEntry.pack(side=LEFT)
# Port row
frame_row3 = Frame(self.frame_left)
frame_row3.pack(side=TOP, padx=20, pady=5)
port_label = Label(frame_row3, text="Port: ")
port_label.pack(side=LEFT)
self.portEntry = Entry(frame_row3, bd=5)
self.portEntry.pack(side=LEFT)
# Connect button
self.enterButton = Button(self.frame_left,
text="Connect",
command=self.handle_enter)
self.enterButton.pack(side=BOTTOM, padx=20, pady=20)
# RIGHT CONTAINER
self.frame_right = Frame(container)
self.frame_right.pack(side=LEFT, padx=20, pady=20)
servers_label = Label(self.frame_right, text="Available servers:")
servers_label.pack(pady=10)
self.servers_lb = Listbox(self.frame_right)
self.servers_lb.pack()
self.servers_lb.bind('<<ListboxSelect>>', self.fill_serverinfo)
pad = Label(self.frame_right, text="")
pad.pack(side=BOTTOM, pady=10)
# Default values
self.exchangeEntry.insert(0, "sudoku")
self.hostEntry.insert(0, "127.0.0.1")
self.portEntry.insert(0, "5672")
# Automatic server discovery
self.servers_list = []
self.announce_listener = AnnounceListener(self.servers_lb,
self.servers_list)
self.announce_listener.start()
def handle_enter(self): # Handle proceed button
exchange = self.exchangeEntry.get()
host = self.hostEntry.get()
port = self.portEntry.get()
self.application.rmq_exchange = exchange
self.application.rmq_host = host
self.application.rmq_port = port
self.application.connect()
def fill_nickname(self, evt):
w = evt.widget
idx = int(w.curselection()[0])
self.entry.delete(0, END)
self.entry.insert(0, w.get(idx))
def fill_serverinfo(self, evt):
if self.servers_lb.size() == 0: return
w = evt.widget
idx = int(w.curselection()[0])
# Exchange name
self.exchangeEntry.delete(0, END)
self.exchangeEntry.insert(0, self.servers_list[idx][0])
# Host name
self.hostEntry.delete(0, END)
self.hostEntry.insert(0, self.servers_list[idx][1])
# Port
self.portEntry.delete(0, END)
self.portEntry.insert(0, self.servers_list[idx][2])
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.padx = 3
self.pady = 3
self.grid()
self.results = []
self.playlists = []
self.vids = []
self.__createWidgets()
def __createWidgets(self):
self.__searchFields()
self.__resultArea()
self.__buttons()
self.__markdownArea()
self.bind('<Return>', self.search_button)
def __buttons(self):
self.resultSelect = Button(text='OK', state=DISABLED)
self.resultSelect.grid(row=5, column=4, sticky=E,
padx=self.padx, pady=self.pady)
self.status = Label(text="", bd=1, relief=SUNKEN, anchor=W)
self.status.grid(row=9, column=0, columnspan=10, sticky=N + E + S + W)
self.__vidButtons()
self.__rmVidButtons()
self.resultSelect.grid_forget()
def __searchFields(self):
Label(text="User", anchor=E).grid(row=0, column=0,
padx=self.padx, pady=self.pady,
sticky=W)
self.user_entry = Entry()
self.user_entry.grid(row=0, column=1, padx=self.padx, pady=self.pady,
sticky=W)
Label(text="Search terms").grid(row=0, column=3,
padx=self.padx, pady=self.pady,
sticky=W)
self.search_terms = Entry()
self.search_terms.grid(row=0, column=4,
padx=self.padx, pady=self.pady,
sticky=W)
Label(text="playlist id").grid(row=1, column=3,
padx=self.padx, pady=self.pady,
sticky=W)
self.playlist_id = Entry()
self.playlist_id.grid(row=1, column=4, padx=self.padx, pady=self.pady,
sticky=W)
self.search_button = Button(text="Search", command=self.__search)
self.search_button.grid(row=2, column=4,
padx=self.padx, pady=self.pady, sticky=E)
def __resultArea(self):
self.result_label = Label(text="Results")
self.result_label.grid(row=2, column=0,
padx=self.padx, pady=self.pady,
sticky=W)
self.resultshowbut = Button(text="View", command=self.__showResults)
self.resultshowbut.grid(row=2, column=1, sticky=W)
self.yScroll = Scrollbar(orient=VERTICAL)
self.xScroll = Scrollbar(orient=HORIZONTAL)
self.listbox = Listbox(xscrollcommand=self.xScroll.set,
yscrollcommand=self.yScroll.set,
selectmode=SINGLE)
self.xScroll.config(command=self.listbox.xview)
self.yScroll.config(command=self.listbox.yview)
def __showResults(self):
self.resultshowbut.config(text="Hide", command=self.__hideResults)
self.yScroll.grid(row=3, column=5, sticky=N + S)
self.xScroll.grid(row=4, column=0, sticky=E + W, columnspan=5)
self.listbox.grid(row=3, column=0, sticky=N + S + E + W, columnspan=5)
self.markdownarea.config(height=10)
def __hideResults(self):
self.resultshowbut.config(text="View", command=self.__showResults)
self.yScroll.grid_forget()
self.xScroll.grid_forget()
self.listbox.grid_forget()
self.markdownarea.config(height=30)
def __markdownArea(self):
self.markdownlabel = Label(text="Markdown")
self.mdyScroll = Scrollbar(orient=VERTICAL)
self.mdxScroll = Scrollbar(orient=HORIZONTAL)
self.markdownarea = Text(wrap=WORD, height=10,
yscrollcommand=self.mdyScroll.set,
xscrollcommand=self.mdxScroll.set)
self.copymarkdown = Button(text="Copy To Clipboard",
command=self.__copyMarkdown)
self.mdxScroll.config(command=self.markdownarea.xview)
self.mdyScroll.config(command=self.markdownarea.yview)
def __vidButtons(self):
self.modtitle = Button(text='Modify titles', command=self.__modTitles)
#self.modtitle.grid(row=5, column=0, sticky=W, columnspan=2,
# padx=self.padx, pady=self.pady)
self.getcaps = Button(text="Get captions", command=self.__getCaptions)
self.getcaps.grid(row=5, column=2, columnspan=3, sticky=E,
padx=self.padx, pady=self.pady)
def __rmVidButtons(self):
self.modtitle.grid_remove()
self.getcaps.grid_remove()
self.bind('<Return>', self.search_button)
def __search(self):
user = self.user_entry.get()
playlist = self.playlist_id.get()
searchterms = self.search_terms.get()
self.__showResults()
self.resultSelect.config(state=DISABLED)
self.__rmVidButtons()
self.__rmMarkdown()
if not self.__validparams(user, searchterms, playlist):
return False
if len(playlist) > 0:
self.__searchPlaylist(playlist)
return
self.__searchUser(user, searchterms)
def __showMarkdown(self):
self.markdownlabel.grid(row=5, column=0,
padx=self.padx, pady=self.pady,
sticky=W)
self.markdownarea.grid(row=6, column=0, columnspan=5,
padx=self.padx, pady=self.pady,
sticky=N + S + E + W)
self.mdyScroll.grid(row=6, column=5, sticky=N + S)
self.mdxScroll.grid(row=7, column=0, sticky=E + W, columnspan=5)
self.copymarkdown.grid(row=8, column=2, columnspan=3, sticky=E,
padx=self.padx, pady=self.pady)
def __rmMarkdown(self):
self.markdownarea.grid_forget()
self.markdownlabel.grid_forget()
self.copymarkdown.grid_forget()
self.mdyScroll.grid_forget()
self.mdxScroll.grid_forget()
def __searchPlaylist(self, playlistid):
self.__getvids(playlistid)
def __searchUser(self, user, searchterms):
self.listbox.delete(0, END)
self.__status("Searching for%splaylists by user \"%s\"" % (
" \"%s\" " % searchterms if len(searchterms) else " ",
user))
self.playlists = []
try:
self.playlists = lib.yt.search.PlaylistSearch(user=user,
search=searchterms).query()
except HTTPError:
self.__status("User %s does not exist at youtube" % user)
return
if self.playlists is None or len(self.playlists) == 0:
self.__status("Search returned no results")
return
self.__populateResults([v['title'] for v in self.playlists])
self.resultSelect.config(command=self.__getVidsFromSelected,
state=NORMAL)
self.__status("")
self.resultSelect.grid(row=5, column=4, sticky=E,
padx=self.padx, pady=self.pady)
def __populateResults(self, values):
self.listbox.delete(0, END)
for i, val in enumerate(values):
self.listbox.insert(i, val)
self.listbox.activate(0)
self.listbox.selection_set(0)
def __getVidsFromSelected(self):
selected = int(self.listbox.curselection()[0])
self.__getvids(self.playlists[selected]['id'])
def __getvids(self, playlistid):
self.playlist_id.delete(0, END)
self.playlist_id.insert(0, playlistid)
self.resultSelect.grid_forget()
title = playlistid
if len(self.playlists) > 0:
for playlist in self.playlists:
if playlist['id'] == playlistid:
title = playlist['title']
break
self.__status("Getting videos for %s" % title)
self.listbox.delete(0, END)
try:
self.vids = lib.yt.search.PlaylistVideoSearch(
id=playlistid).query()
self.__populateResults([v['title'] for v in self.vids])
self.__status("%d Videos found" % len(self.vids))
self.__vidButtons()
self.bind('<Return>', self.getcaps)
except HTTPError:
self.__status("No videos found! is %s a valid playlist?" %
playlistid)
def __status(self, msg):
if len(msg) > 75:
msg = msg[:70] + '...'
self.status.config(text=msg)
self.status.update_idletasks()
def __trackSelect(self, vid, tracks, preftrack=None):
pref = self.__prefAvailable(preftrack, tracks)
if pref is None:
sel = lib.trackSelect.TrackSelect(self, vid=vid,
tracks=tracks)
if sel.result is None:
self.__status("skipped")
tracks = None
else:
tracks = [sel.result[0]]
if sel.preflang is not None:
preftrack['lang'] = sel.preflang
if sel.prefname is not None:
preftrack['name'] = sel.prefname
else:
tracks = pref
return tracks, preftrack
def __getCaptions(self):
preftrack = {'name': None, 'lang': None}
self.listbox.delete(0, END)
self.markdownarea.delete(1.0, END)
self.__showMarkdown()
for i, vid in enumerate(self.vids):
nocapmsg = '[%02d] --NO CAPTIONS-- %s' % (i + 1, vid['title'])
tracks = lib.yt.search.CaptionSearch(id=vid['id']).query()
self.vids[i]['text'] = ''
if len(tracks) == 0:
self.__status('No captions available for %s' %
self.vids[i]['title'])
self.listbox.insert(END, nocapmsg)
elif len(tracks) > 1:
sel = self.__trackSelect(vid, tracks, preftrack)
if sel[0] is None:
msg = '[%02d] --SKIPPED-- %s' % (i + 1, vid['title'])
self.listbox.insert(END, msg)
self.listbox.see(END)
continue
tracks = sel[0]
if len(tracks) == 1:
self.__trackCaps(i, tracks, nocapmsg)
self.__status('')
self.__hideResults()
def __trackCaps(self, vidIndex, tracks, nocapmsg):
i = vidIndex
vid = self.vids[i]
msg = '%02d of %02d Getting captions for %s' % (
i + 1, len(self.vids), self.vids[i]['title'])
self.__status(msg)
self.listbox.insert(END, msg)
self.vids[i]['text'] = lib.markdown.heading(vid['title'])
captions = lib.yt.search.GetCaptions(id=vid['id'],
lang=tracks[0]['lang'],
name=tracks[0]['name'])
captions.query()
captiontext = captions.textOnly()
sleep(0.2)
msg = nocapmsg
if captiontext is not None and len(captiontext) > 0:
self.vids[i]['text'] += (lib.markdown.to_utf8(captiontext)
+ '\n\n')
msg = '[%02d] --DONE-- %s' % (i + 1, vid['title'])
self.listbox.delete(END, END)
self.listbox.insert(END, msg)
self.listbox.see(END)
self.markdownarea.insert(END, self.vids[i]['text'])
self.markdownarea.see(END)
def __prefAvailable(self, preftrack, tracks):
if preftrack['lang'] is None:
return None
pref = None
for track in tracks:
if (track['lang'] == preftrack['lang'] and
track['name'] == preftrack['name']):
return [track]
if track['lang'] == preftrack['lang'] and pref is None:
pref = [track]
return pref
def __modTitles(self):
pass
def __validparams(self, user, searchterms, playlist):
if len(user) == 0 and len(playlist) == 0:
msg = "Either a valid youtube user or playlist id must be given."
tkMessageBox.showwarning("missing information", msg)
return False
if len(user) > 0 and not self.__validstring(user):
msg = "The user given contains invalid characters"
tkMessageBox.showwarning('Bad user', msg)
return False
if len(playlist) > 0 and not self.__validstring(playlist):
msg = "The playlist given contains invalid characters"
tkMessageBox.showwarning('Bad playlist', msg)
return False
if len(searchterms) > 0 and not self.__validstring(searchterms, True):
msg = "The search terms given contain invalid characters"
tkMessageBox.showwarning('Bad search', msg)
return False
return True
def __validstring(self, s, spacechar=False):
validchars = string.letters + string.digits + string.punctuation
if spacechar:
validchars += ' '
for c in s:
if c not in validchars:
return False
return True
def __copyMarkdown(self):
self.markdownarea.clipboard_clear()
self.markdownarea.clipboard_append(self.markdownarea.get(1.0, END))
class LoginFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.db = self.parent.db
font = ("Helvetica", 20)
self.userEntry = Entry(self.parent, width=15, font=font)
self.passEntry = Entry(self.parent, width=15, show='*', font=font)
self.passEntry.bind('<Return>', self.login)
buttonSubmit = Button(self.parent, text="Login", command=self.login, width=10)
buttonRegSwitch = Button(self.parent, text="New User",
command=self.viewRegister, width=10)
self.userRegEntry = Entry(self.parent, width=15, font=font)
self.passRegEntry = Entry(self.parent, width=15, show='*',
font=font)
self.passRegEntry.bind('<Return>', self.register)
buttonRegister = Button(self.parent, text="Register",
command=self.register, width=10)
buttonBack = Button(self.parent, text="Back",
command=self.viewLogin, width=10)
self.login_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.register_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.login_canvas.create_text(300, 40, text="Login", font=font, fill="#004183")
self.login_canvas.create_text(170, 80, text="Username:"******"Password:"******"Register", font=font, fill="#004183")
self.register_canvas.create_text(170, 80, text="Username:"******"Password:"******"""SELECT * FROM
users WHERE username='******'"""
%(usernameGiven.lower().strip()))
if len(userDetails)==1:
passHash = userDetails[0][2]
if (hashlib.sha1(passwordGiven).hexdigest() == passHash):
self.parent.login(User(userDetails[0]))
loginFailed = False
else:
loginFailed = True
else:
loginFailed = True
if loginFailed:
tkMessageBox.showerror("Login Failed",
"Invalid username or password")
self.userEntry.delete(0, END)
self.passEntry.delete(0, END)
def register(self):
username = self.userRegEntry.get()
passwd = self.passRegEntry.get()
if username != '' and passwd != '':
username = username.lower().strip()
passHash = hashlib.sha1(passwd).hexdigest()
self.db.sql("""INSERT INTO users (username, passwd) VALUES
('%s', '%s')"""%(username, passHash))
self.viewLogin()
def viewRegister(self):
self.login_canvas.pack_forget()
self.register_canvas.pack()
def viewLogin(self):
self.register_canvas.pack_forget()
self.login_canvas.pack()
class WindowExample(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.result = 0
self.master.title("This is a test")
self.master.minsize(width=600, height=800)
#self.master.
self.prompt = Label(self,
text="Enter a number:",
anchor="w",
fg="#984301")
self.entry = Entry(self, width=50, highlightcolor="red")
self.submit = Button(self, text="Submit", command=self.calculate)
self.exit = Button(self, text="Exit", command=parent.destroy, fg="red")
self.output = Label(self, text="")
self.menu = Menu(self, title="Menu test", bg="black")
self.canvas = Canvas(self,
cursor="circle",
highlightcolor="blue",
bg="#019bf0")
self.button1 = Button(self, text = "tast antum", bg = "red", fg = "green", command = self.newWindow, \
activebackground = "red", activeforeground = "blue", relief = "sunken", cursor = "dot")
self.newFrame = Frame(self, bg="green", highlightcolor="blue")
self.button2 = Button(self.newFrame, text="This is a tast")
self.button2.grid()
self.scale = Scale(self,
from_=50,
to_=60,
orient="horizontal",
digits=3,
resolution=0.25,
highlightcolor="red",
command=self.calculate)
self.scale.pack()
self.open_file_button = Button(self,
text="Open File",
command=self.openFile)
self.prompt.pack(side="top", fill="x")
self.entry.pack(side="top", fill="x")
self.output.pack(side="top", fill="x", expand=True)
self.submit.pack(side="right")
self.exit.pack(side="left")
self.button1.pack(fill="x")
self.newFrame.pack(side="bottom", fill="x", expand=True)
self.button2.grid()
self.canvas.pack()
self.open_file_button.pack()
#self.slider.pack()
#self.tk = Tkinter.Tk()
#self.tk.withdrow()
#self.file_path = Tkinter.filedialog.askopenfilename()
#print("test")
self.entry.insert(string="3", index=0)
#self.entry.insert(string = "blahblah", index = 3)
def calculate(self, integer):
integer = float(integer)
#try:
# i = int(self.entry.get())
# self.result = "%s*2=%s" % (i, i*2)
#except ValueError:
# self.result = "Please enter numbers only"
self.entry.delete(0, len(self.entry.get()))
self.result = "%s*2=%s" % (integer, integer * 2)
self.entry.insert(0, integer)
self.output.configure(text=self.result)
def newWindow(self):
try:
r2 = Tk()
r2.mainloop()
except ValueError:
return None
def openFile(self):
file_in = tkFileDialog.askopenfilename()
self.output.configure(text=file_in)
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title("IAF CALC 0.01")
self.pack(fill=BOTH, expand=1)
self.configure(background='white')
frameTOP = Frame(self)
frameTOP.config(bg="white")
frameTOP.pack(side=TOP)
frameFILES = Frame(frameTOP)
frameFILES.pack(side=LEFT, padx=10)
# --- BUTTON FOR FILE 1 --- #
frameF1 = LabelFrame(frameFILES,
text="Eyes open file:",
relief=FLAT,
borderwidth=1,
background="white")
frameF1.pack(fill=X, expand=1)
self.nameF1 = Entry(frameF1, width=50)
self.nameF1.config(bg="lightgray")
self.nameF1.pack(side=LEFT)
self.nameF1.delete(0, END)
self.nameF1.insert(0, "")
self.buttonLoadFile1 = Button(frameF1,
text="...",
command=self.askOpenFile1)
self.buttonLoadFile1.pack(side=LEFT, padx=5, pady=5)
# ----------------------- #
# --- BUTTON FOR FILE 2 --- #
frameF2 = LabelFrame(frameFILES,
text="Eyes closed file:",
relief=FLAT,
borderwidth=1,
background="white")
frameF2.pack(fill=X, expand=1)
self.nameF2 = Entry(frameF2, width=50)
self.nameF2.config(bg="lightgray")
self.nameF2.pack(side=LEFT)
self.nameF2.delete(0, END)
self.nameF2.insert(0, "")
self.buttonLoadFile2 = Button(frameF2,
text="...",
command=self.askOpenFile2)
self.buttonLoadFile2.pack(side=LEFT, padx=5, pady=5)
# ----------------------- #
# --- BUTTON FOR FILE OUTPUT --- #
frameO = LabelFrame(frameFILES,
text="Output directory:",
relief=FLAT,
borderwidth=1,
background="white")
frameO.pack(fill=X, expand=1)
self.nameO = Entry(frameO, width=50)
self.nameO.config(bg="lightgray")
self.nameO.pack(side=LEFT)
self.nameO.delete(0, END)
self.nameO.insert(0, "")
self.buttonSelectOutput = Button(frameO,
text="...",
command=self.askOutputDirectory)
self.buttonSelectOutput.pack(side=LEFT, padx=5, pady=5)
# -------------------------------#
# self.pack()
# self.pack(fill=Y, expand=1)
# ---------- PSD PARAMETER SELECTION ---------- #
framePARAM = Frame(frameTOP)
framePARAM.config(bg="white")
framePARAM.pack(side=LEFT, fill=X)
frame = LabelFrame(framePARAM,
text="PSD Parameters",
relief=RIDGE,
borderwidth=1,
background="white")
frame.pack(fill=BOTH, expand=1, side=TOP)
wFs = Label(frame, text="Fs:", bg="white")
wFs.pack(side=LEFT)
self.inputFs = Entry(frame, width=5)
self.inputFs.pack(side=LEFT, padx=5)
self.inputFs.delete(0, END)
self.inputFs.insert(0, "500")
wWS = Label(frame, text="Window size:", bg="white")
wWS.pack(side=LEFT)
self.inputWinSize = Entry(frame, width=5)
self.inputWinSize.pack(side=LEFT, padx=5)
self.inputWinSize.delete(0, END)
self.inputWinSize.insert(0, "1024")
wOL = Label(frame, text="Overlap:", bg="white")
wOL.pack(side=LEFT)
self.inputOverlap = Entry(frame, width=5)
self.inputOverlap.pack(side=LEFT, padx=5)
self.inputOverlap.delete(0, END)
self.inputOverlap.insert(0, "512")
wWT = Label(frame, text="Window function:", bg="white")
wWT.pack(side=LEFT)
variable = StringVar(frame)
variable.set("Hamming") # default value
self.inputWinType = OptionMenu(frame, variable, "Hamming", "Bartlett",
"Blackman", "Hanning", "None")
self.inputWinType.config(bg="white", width=10)
self.inputWinType.pack(side=LEFT)
buttonRun = Button(frame, text="GO!", command=self.goTime)
buttonRun.pack(side=RIGHT)
# Channel selector
frameCh = LabelFrame(framePARAM,
text="Channels",
relief=RIDGE,
borderwidth=1,
background="white")
frameCh.pack(fill=BOTH, expand=1, side=TOP)
self.EOch1 = IntVar()
self.inputEOch1 = Checkbutton(frameCh,
text="1",
variable=self.EOch1,
bg="white")
self.inputEOch1.pack(side=LEFT)
self.EOch2 = IntVar()
self.inputEOch2 = Checkbutton(frameCh,
text="2",
variable=self.EOch2,
bg="white")
self.inputEOch2.pack(side=LEFT)
self.EOch3 = IntVar()
self.inputEOch3 = Checkbutton(frameCh,
text="3",
variable=self.EOch3,
bg="white")
self.inputEOch3.pack(side=LEFT)
self.EOch4 = IntVar()
self.inputEOch4 = Checkbutton(frameCh,
text="4",
variable=self.EOch4,
bg="white")
self.inputEOch4.pack(side=LEFT)
self.EOch5 = IntVar()
self.inputEOch5 = Checkbutton(frameCh,
text="5",
variable=self.EOch5,
bg="white")
self.inputEOch5.pack(side=LEFT)
self.EOch6 = IntVar()
self.inputEOch6 = Checkbutton(frameCh,
text="6",
variable=self.EOch6,
bg="white")
self.inputEOch6.pack(side=LEFT)
self.EOch7 = IntVar()
self.inputEOch7 = Checkbutton(frameCh,
text="7",
variable=self.EOch7,
bg="white")
self.inputEOch7.pack(side=LEFT)
self.EOch8 = IntVar()
self.inputEOch8 = Checkbutton(frameCh,
text="8",
variable=self.EOch8,
bg="white")
self.inputEOch8.pack(side=LEFT)
# IAF Calculation parameters
frameIAF = LabelFrame(framePARAM,
text="IAF Search Limits",
relief=RIDGE,
borderwidth=1,
background="white")
frameIAF.pack(fill=BOTH, expand=1, side=TOP)
labelLowBound = Label(frameIAF, text="Lower limit (Hz):", bg="white")
labelLowBound.pack(side=LEFT)
self.inputLowBound = Entry(frameIAF, width=5)
self.inputLowBound.pack(side=LEFT, padx=5)
self.inputLowBound.delete(0, END)
self.inputLowBound.insert(0, "7")
labelUpBound = Label(frameIAF, text="Upper limit (Hz):", bg="white")
labelUpBound.pack(side=LEFT)
self.inputUpBound = Entry(frameIAF, width=5)
self.inputUpBound.pack(side=LEFT, padx=5)
self.inputUpBound.delete(0, END)
self.inputUpBound.insert(0, "14")
self.GaussVar = IntVar()
self.inputGauss = Checkbutton(frameIAF,
text="Gauss",
variable=self.GaussVar,
bg="white")
self.inputGauss.pack(side=LEFT)
buttonRun = Button(frameIAF, text="IAF!", command=self.calculateIAF)
buttonRun.pack(side=RIGHT)
self.pack()
# """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
# """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
# END OF TOP FRAME
# """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
# """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
# my variables
self.chSelect = 0
self.chOther = 0
self.P1 = ndarray(1)
self.f1 = ndarray(1)
self.P2 = ndarray(1)
self.f2 = ndarray(1)
self.filename1 = "..."
self.filename2 = "..."
self.IAF = 10
self.doGauss = True
# FIGURE STUFF !!!
self.Pmax = 0
self.Pmin = 0
self.Dmax = 0
self.Dmin = 0
frameBOTTOM = Frame(self)
frameBOTTOM.config(bg="white")
frameBOTTOM.pack(side=BOTTOM, pady=10)
frameFig = LabelFrame(frameBOTTOM,
text="Spectrum",
relief=RIDGE,
borderwidth=1,
background="white")
frameFig.pack(fill=X, expand=1, side=LEFT, padx=10)
self.fig1 = matplotlib.figure.Figure(figsize=(7, 3),
dpi=100) #,frameon=False)
self.fig1.set_facecolor('white')
self.fig = matplotlib.backends.backend_tkagg.FigureCanvasTkAgg(
self.fig1, master=frameFig)
self.a1 = self.fig1.add_subplot(121)
self.a2 = self.fig1.add_subplot(122)
self.fig.show()
self.fig.get_tk_widget().pack(side=BOTTOM)
frameConfig = LabelFrame(frameBOTTOM,
text="Filter configuration",
relief=RAISED,
borderwidth=1,
background="white")
frameConfig.pack(fill=BOTH, expand=1, side=RIGHT, padx=10)
frameIAF = LabelFrame(frameConfig,
text="Individual Alpha Frequency (IAF)")
frameIAF.config(bg="white")
frameIAF.pack(expand=1, side=TOP, padx=10)
self.inputIAF = Entry(frameIAF, width=5)
self.inputIAF.pack(side=LEFT, padx=5)
self.inputIAF.delete(0, END)
self.inputIAF.insert(0, "0")
self.buttonWriteDefault = Button(frameIAF,
text="Update Filters",
command=self.updateFilters)
self.buttonWriteDefault.pack(side=LEFT, padx=5, pady=5)
frameFilters = LabelFrame(frameConfig,
text="Filters",
relief=RAISED,
borderwidth=1,
background="white")
frameFilters.pack(fill=X, expand=1, side=TOP)
# THETA FRAME
frameTheta = LabelFrame(frameFilters,
text="Theta",
relief=RAISED,
borderwidth=1,
background="white")
frameTheta.pack(expand=1, side=TOP, pady=5, padx=5)
self.inputThetaLow = Entry(frameTheta, width=8)
self.inputThetaLow.pack(side=LEFT, padx=5, pady=5)
self.inputThetaLow.delete(0, END)
self.inputThetaLow.insert(0, "0")
self.inputThetaHigh = Entry(frameTheta, width=8)
self.inputThetaHigh.pack(side=LEFT, padx=5, pady=5)
self.inputThetaHigh.delete(0, END)
self.inputThetaHigh.insert(0, "0")
# BETA FRAME
frameBeta = LabelFrame(frameFilters,
text="Beta",
relief=RAISED,
borderwidth=1,
background="white")
frameBeta.pack(expand=1, side=TOP, pady=5, padx=5)
self.inputBetaLow = Entry(frameBeta, width=8)
self.inputBetaLow.pack(side=LEFT, padx=5, pady=5)
self.inputBetaLow.delete(0, END)
self.inputBetaLow.insert(0, "0")
self.inputBetaHigh = Entry(frameBeta, width=8)
self.inputBetaHigh.pack(side=LEFT, padx=5, pady=5)
self.inputBetaHigh.delete(0, END)
self.inputBetaHigh.insert(0, "0")
# SMR FRAME
frameSMR = LabelFrame(frameFilters,
text="SMR",
relief=RAISED,
borderwidth=1,
background="white")
frameSMR.pack(expand=1, side=TOP, pady=5, padx=5)
self.inputSMRLow = Entry(frameSMR, width=8)
self.inputSMRLow.pack(side=LEFT, padx=5, pady=5)
self.inputSMRLow.delete(0, END)
self.inputSMRLow.insert(0, "0")
self.inputSMRHigh = Entry(frameSMR, width=8)
self.inputSMRHigh.pack(side=LEFT, padx=5, pady=5)
self.inputSMRHigh.delete(0, END)
self.inputSMRHigh.insert(0, "0")
frameButtons = LabelFrame(frameConfig,
text="Commands",
relief=RAISED,
borderwidth=1,
background="white")
frameButtons.pack(expand=1, side=BOTTOM)
self.buttonWriteConfig = Button(frameButtons,
text="Write Filters",
command=self.writeFilters)
self.buttonWriteConfig.pack(side=LEFT, padx=5, pady=5)
self.buttonWriteDefault = Button(frameButtons,
text="Reset to Defaults",
command=self.resetIAFtoDefault)
self.buttonWriteDefault.pack(side=LEFT, padx=5, pady=5)
# self.buttonVisualize = Button(frameButtons, text="VIS",command=self.resetIAFtoDefault)
# self.buttonVisualize.pack(side=LEFT,padx=5,pady=5)
self.buttonPrintFig = Button(frameButtons,
text="Print Figure",
command=self.printFigureToFile)
self.buttonPrintFig.pack(side=LEFT, padx=5, pady=5)
def getChannelList(self):
# Initialize
self.chSelect = asarray([])
self.chOther = asarray([])
if self.EOch1.get():
self.chSelect = append(self.chSelect, 0)
else:
self.chOther = append(self.chOther, 0)
if self.EOch2.get():
self.chSelect = append(self.chSelect, 1)
else:
self.chOther = append(self.chOther, 1)
if self.EOch3.get():
self.chSelect = append(self.chSelect, 2)
else:
self.chOther = append(self.chOther, 2)
if self.EOch4.get():
self.chSelect = append(self.chSelect, 3)
else:
self.chOther = append(self.chOther, 3)
if self.EOch5.get():
self.chSelect = append(self.chSelect, 4)
else:
self.chOther = append(self.chOther, 4)
if self.EOch6.get():
self.chSelect = append(self.chSelect, 5)
else:
self.chOther = append(self.chOther, 5)
if self.EOch7.get():
self.chSelect = append(self.chSelect, 6)
else:
self.chOther = append(self.chOther, 6)
if self.EOch8.get():
self.chSelect = append(self.chSelect, 7)
else:
self.chOther = append(self.chOther, 7)
def updateFilters(self):
# SET THETA
self.inputThetaLow.delete(0, END)
self.inputThetaLow.insert(0,
"%.2f" % (float(self.inputIAF.get()) * 0.4))
self.inputThetaHigh.delete(0, END)
self.inputThetaHigh.insert(0,
"%.2f" % (float(self.inputIAF.get()) * 0.6))
# SET BETA
self.inputBetaLow.delete(0, END)
self.inputBetaLow.insert(0,
"%.2f" % (float(self.inputIAF.get()) * 1.2))
self.inputBetaHigh.delete(0, END)
self.inputBetaHigh.insert(0, 25)
# SET SMR
self.inputSMRLow.delete(0, END)
self.inputSMRLow.insert(0, "%.2f" % (float(self.inputIAF.get()) * 1.2))
self.inputSMRHigh.delete(0, END)
self.inputSMRHigh.insert(0,
"%.2f" % (float(self.inputIAF.get()) * 1.5))
def resetIAFtoDefault(self):
self.inputIAF.delete(0, END)
self.inputIAF.insert(0, "10")
self.updateFilters()
def calculateIAF(self):
self.getChannelList()
print "LOLOL calculating IAF"
m1 = 20 * log10(mean(self.P1[self.chSelect.astype(int), :], axis=0))
m2 = 20 * log10(mean(self.P2[self.chSelect.astype(int), :], axis=0))
d = m2 - m1
if self.GaussVar.get():
# print d.shape
# print gauss_signal.shape
d_gauss = d[bitwise_and(self.f1 > int(self.inputLowBound.get()),
self.f1 < int(self.inputUpBound.get()))]
gauss_signal = signal.gaussian(d_gauss.shape[0], 1)
d_gauss = d_gauss * gauss_signal
d[bitwise_and(self.f1 > int(self.inputLowBound.get()),
self.f1 < int(self.inputUpBound.get()))] = d_gauss
self.a2 = plotIAF(self.f1, d, "purple", self.a2, "IAF")
# Get dat IAF val
d_search = d[bitwise_and(self.f1 > int(self.inputLowBound.get()),
self.f1 < int(self.inputUpBound.get()))]
f_search = self.f1[bitwise_and(self.f1 > int(self.inputLowBound.get()),
self.f1 < int(self.inputUpBound.get()))]
f_idx = argmax(d_search)
print f_search[f_idx]
self.inputIAF.delete(0, END)
self.inputIAF.insert(0, "%.2f" % (f_search[f_idx]))
# Autoscale
self.Dmin = amin(d_search) - 2
self.Dmax = amax(d_search) + 2
self.a2.set_ylim(
self.Dmin, self.Dmax) # little modifier to differentiate the peak
# IAF position
self.a2.vlines(f_search[f_idx], self.Dmin, self.Dmax, color="Cyan")
# Search limits
self.a2.vlines(int(self.inputLowBound.get()),
self.Dmin,
self.Dmax,
linestyles=":",
linewidth=0.25)
self.a2.vlines(int(self.inputUpBound.get()),
self.Dmin,
self.Dmax,
linestyles=":",
linewidth=0.25)
self.fig.show()
# Set filter configs
def goTime(self):
print "ITS GO TIME!"
print self.filename1
print self.filename2
self.getChannelList()
print self.chSelect
print self.chOther
self.f1, self.P1 = computeSpectrum(self.filename1,
int(self.inputFs.get()),
int(self.inputWinSize.get()),
int(self.inputOverlap.get()))
self.f2, self.P2 = computeSpectrum(self.filename2,
int(self.inputFs.get()),
int(self.inputWinSize.get()),
int(self.inputOverlap.get()))
# Plotting time
self.a1.cla()
self.a1 = plotSpectrum(self.f1, self.P1, "blue", self.a1,
"Power spectrum", self.chSelect, self.chOther)
self.a1 = plotSpectrum(self.f2, self.P2, "red", self.a1,
"Power spectrum", self.chSelect, self.chOther)
# Trying to autoscale
P1_ROI = 20 * log10(self.P1[:, bitwise_and(self.f1 > 1, self.f1 < 20)])
P2_ROI = 20 * log10(self.P2[:, bitwise_and(self.f2 > 1, self.f2 < 20)])
self.Pmax = amax([amax(P1_ROI), amax(P2_ROI)])
self.Pmin = amin([(amin(P1_ROI)), amin(P2_ROI)])
self.a1.set_ylim(self.Pmin, self.Pmax)
# Autoscale success :>
self.fig.show()
def writeFilters(self):
f_theta = open(self.nameO.get() + "/theta.f", "w")
f_theta.write(
"<OpenViBE-SettingsOverride>\n\t<SettingValue>Butterworth</SettingValue>\n\t<SettingValue>Band pass</SettingValue>\n\t<SettingValue>4</SettingValue>\n\t<SettingValue>{:.2f}</SettingValue>\n\t<SettingValue>{:.2f}</SettingValue>\n\t<SettingValue>0.5</SettingValue>\n</OpenViBE-SettingsOverride>"
.format(float(self.inputThetaLow.get()),
float(self.inputThetaHigh.get())))
f_theta.close()
f_beta = open(self.nameO.get() + "/beta.f", "w")
f_beta.write(
"<OpenViBE-SettingsOverride>\n\t<SettingValue>Butterworth</SettingValue>\n\t<SettingValue>Band pass</SettingValue>\n\t<SettingValue>4</SettingValue>\n\t<SettingValue>{:.2f}</SettingValue>\n\t<SettingValue>{:.2f}</SettingValue>\n\t<SettingValue>0.5</SettingValue>\n</OpenViBE-SettingsOverride>"
.format(float(self.inputBetaLow.get()),
float(self.inputBetaHigh.get())))
f_beta.close()
f_smr = open(self.nameO.get() + "/smr.f", "w")
f_smr.write(
"<OpenViBE-SettingsOverride>\n\t<SettingValue>Butterworth</SettingValue>\n\t<SettingValue>Band pass</SettingValue>\n\t<SettingValue>4</SettingValue>\n\t<SettingValue>{:.2f}</SettingValue>\n\t<SettingValue>{:.2f}</SettingValue>\n\t<SettingValue>0.5</SettingValue>\n</OpenViBE-SettingsOverride>"
.format(float(self.inputSMRLow.get()),
float(self.inputSMRHigh.get())))
f_smr.close()
def printFigureToFile(self):
self.fig1.savefig(self.nameO.get() + "/IAF_spectrum.png")
def askOpenFile1(self):
ftypes = [('asdadfh', '*.txt'), ('All files', '*')]
dlg = tkFileDialog.Open(self, filetypes=ftypes)
self.filename1 = dlg.show()
self.nameF1.delete(0, END)
self.nameF1.insert(0, self.filename1)
def askOpenFile2(self):
ftypes = [('asdadfh', '*.txt'), ('All files', '*')]
dlg = tkFileDialog.Open(self, filetypes=ftypes)
self.filename2 = dlg.show()
self.nameF2.delete(0, END)
self.nameF2.insert(0, self.filename2)
def askOutputDirectory(self):
dlg = tkFileDialog.askdirectory()
#self.outputdir = dlg.show()
self.outputdir = dlg
self.nameO.delete(0, END)
self.nameO.insert(0, self.outputdir)
class NicknameView:
"""
Main UI responsible for handling user inputs and sudoku board viewing
"""
def __init__(self, container, main_ui):
self.main_ui = main_ui
self.nicknameLabel = Label(container, text="Welcome to Sudoku!")
self.nicknameLabel.pack(side=TOP)
self.frame_left = Frame(container)
self.frame_left.pack(side=LEFT, padx=20, pady=20)
self.nicknameLabel = Label(self.frame_left, text="Enter nickname: ")
self.nicknameLabel.pack(side=LEFT)
self.entry = Entry(self.frame_left, bd=5)
self.entry.pack(side=LEFT)
self.enterButton = Button(self.frame_left,
text="Proceed",
command=self.handle_enter)
self.enterButton.pack(side=LEFT, padx=20, pady=20)
self.frame_right = Frame(container)
self.frame_right.pack(side=RIGHT)
self.nicknameLabel = Label(self.frame_right,
text="Previously used names:")
self.nicknameLabel.pack()
nickname_lb = Listbox(self.frame_right)
for idx, val in enumerate(read_usernames(
)): # Insert all previously used usernames to list
nickname_lb.insert(idx, val)
nickname_lb.pack()
nickname_lb.bind('<<ListboxSelect>>', self.fill_nickname)
def handle_enter(self): # Handle proceed button
nickname = self.entry.get()
if self.validate_nickname(nickname):
save_username(nickname) # Save new username to file
self.main_ui.nickname = nickname
print("Proceeding")
self.main_ui.server_address_view() # Show server screen
def fill_nickname(self, evt):
w = evt.widget
if w.size() == 0:
return
idx = int(w.curselection()[0])
self.entry.delete(0, END)
self.entry.insert(0, w.get(idx))
def validate_nickname(self, nickname):
validation = re.findall("^[a-zA-Z0-9]*$", nickname)
if len(nickname) == 0:
tkMessageBox.showinfo(
"Error", "Nickname must be at least 1 character long")
return False
elif len(nickname) > 8:
tkMessageBox.showinfo("Error",
"Nickname must be 8 characters or shorter")
return False
elif len(validation) == 0 or (len(validation) > 0
and validation[0] != nickname):
tkMessageBox.showinfo("Error",
"Only alphanumeric characters allowed")
return False
return True
class NGA_Window_LED_Advanced(Frame):
led = None
led1amp = 100.0
led2amp = 100.0
led3amp = 100.0
led4amp = 100.0
sys = None
wLED = None #window of pointer to main LED window
def __init__(self, parent, sys):
Frame.__init__(self, parent)
#self.wLED = sys.wL #LED Window
self.parent = parent
self.sys = sys
self.sys.c_led_advanced = self
# get window configurations
self.parent.geometry(self.sys.win_cfg.wLEDAdvanced)
self.parent.title(self.sys.win_cfg.sLEDAdvanced)
# draw window
self.initUI()
# window defaults
self.update_led_on_off()
def initUI(self):
self.style = Style().configure("TFrame", background=self.sys.win_cfg.cBackground)
self.pack(fill=BOTH, expand=1)
# setup labels
self.LED1 = Label(self, width=4, background=self.sys.win_cfg.cLEDOff, text="LED1")
self.LED1.place(x=98, y=45)
self.LED2 = Label(self, width=4, background=self.sys.win_cfg.cLEDOff, text="LED2")
self.LED2.place(x=98, y=75)
self.LED3 = Label(self, width=4, background=self.sys.win_cfg.cLEDOff, text="LED3")
self.LED3.place(x=98, y=105)
self.LED4 = Label(self, width=4, background=self.sys.win_cfg.cLEDOff, text="LED4")
self.LED4.place(x=98, y=135)
# setup entries
titleLabel = Label(self, text=self.sys.win_cfg.sLEDAdvanced,
background=self.sys.win_cfg.cBackground,
width=12, height=1)
titleLabel.place(x=5, y=5)
percentLabel = Label(self, text="0-100 (%)",
background=self.sys.win_cfg.cBackground,
width=8, height=1)
percentLabel.place(x=5, y=22)
self.led1val = Entry(self, width=4,
background=self.sys.win_cfg.cTextBackground)
self.led1val.place(x=10, y=50-4)
self.led2val = Entry(self, width=4,
background=self.sys.win_cfg.cTextBackground)
self.led2val.place(x=10, y=80-4)
self.led3val = Entry(self, width=4,
background=self.sys.win_cfg.cTextBackground)
self.led3val.place(x=10, y=110-4)
self.led4val = Entry(self, width=4,
background=self.sys.win_cfg.cTextBackground)
self.led4val.place(x=10, y=140)
# setup buttons
led1onButton = Button(self, text="LED1",
command=self.led1_on, width=6)
led1onButton.place(x=45, y=45)
led2onButton = Button(self, text="LED2",
command=self.led2_on, width=6)
led2onButton.place(x=45, y=75)
led3onButton = Button(self, text="LED3",
command=self.led3_on, width=6)
led3onButton.place(x=45, y=105)
led4onButton = Button(self, text="LED4",
command=self.led4_on, width=6)
led4onButton.place(x=45, y=135)
# close buttons
closeButton = Button(self, text="Close",
command=self.close_window)
closeButton.place(x=30, y=180)
self.update_duty()
def update_duty(self):
self.led1val.delete(0, END)
self.led1val.insert(0, "{0:.1f}".format(self.led1amp))
self.led2val.delete(0, END)
self.led2val.insert(0, "{0:.1f}".format(self.led2amp))
self.led3val.delete(0, END)
self.led3val.insert(0, "{0:.1f}".format(self.led3amp))
self.led4val.delete(0, END)
self.led4val.insert(0, "{0:.1f}".format(self.led4amp))
def getValues(self):
self.led1amp = float(self.led1val.get())
self.led2amp = float(self.led2val.get())
self.led3amp = float(self.led3val.get())
self.led4amp = float(self.led4val.get())
def byteFromPer(self, val):
return val*(255.0/100.0) #percent (0-100) to (0-255)
def close_window(self):
self.parent.destroy()
def led1_on(self):
self.sys.hw.led.command(NGA_Interface_LED.LED_OFF)
self.getValues()
self.sys.hw.led.duty_cycle(0,self.byteFromPer(self.led1amp))
self.update_regular_led()
def led2_on(self):
self.sys.hw.led.command(NGA_Interface_LED.LED_OFF)
self.getValues()
self.sys.hw.led.duty_cycle(1,self.byteFromPer(self.led2amp))
self.update_regular_led()
def led3_on(self):
self.sys.hw.led.command(NGA_Interface_LED.LED_OFF)
self.getValues()
self.sys.hw.led.duty_cycle(2,self.byteFromPer(self.led3amp))
self.update_regular_led()
def led4_on(self):
self.sys.hw.led.command(NGA_Interface_LED.LED_OFF)
self.getValues()
self.sys.hw.led.duty_cycle(3,self.byteFromPer(self.led4amp))
self.update_regular_led()
def update_led_on_off(self):
if self.sys.hw.led.led_on[0] == True:
self.LED1.configure(background = self.sys.win_cfg.cLEDOn)
if self.sys.hw.led.led_on[0] == False:
self.LED1.configure(background = self.sys.win_cfg.cLEDOff)
if self.sys.hw.led.led_on[1] == True:
self.LED2.configure(background = self.sys.win_cfg.cLEDOn)
if self.sys.hw.led.led_on[1] == False:
self.LED2.configure(background = self.sys.win_cfg.cLEDOff)
if self.sys.hw.led.led_on[2] == True:
self.LED3.configure(background = self.sys.win_cfg.cLEDOn)
if self.sys.hw.led.led_on[2] == False:
self.LED3.configure(background = self.sys.win_cfg.cLEDOff)
if self.sys.hw.led.led_on[3] == True:
self.LED4.configure(background = self.sys.win_cfg.cLEDOn)
if self.sys.hw.led.led_on[3] == False:
self.LED4.configure(background = self.sys.win_cfg.cLEDOff)
def update_regular_led(self):
if (self.parent.winfo_exists() == 1): #window exists
self.sys.c_led.update_led() # inform led window
self.update_led_on_off()
def update_led(self):
self.update_led_on_off()
class ChineseCheckerUI(Frame):
def __init__(self, parent, options = 0):
Frame.__init__(self, parent)
if options == 0:
self.full = 0
self.game = boardState(options = 'smallGame')
self.HEIGHT = pieceSize * self.game.height + 2 * margin
self.WIDTH = pieceSize * self.game.mid_width_max + 2 * margin
elif options == 1:
self.full = 1
self.game = boardState(options = 'midGame')
self.HEIGHT = pieceSize * self.game.height + 2 * margin
self.WIDTH = pieceSize * self.game.mid_width_max + 2 * margin
self.possibleMoves = []
self.cantGo = []
self.weights = [0.911, 0.140, 0.388]
self.depth = 2
self.turn = 1
self.row, self.col = -1, -1
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title("Chinese Checkers")
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self)
for i in xrange(self.game.height):
for j in xrange(self.game.mid_width_max):
if self.game.board[i][j] == 1:
self.canvas.create_oval(margin + j * pieceSize + spacing,
margin + i * pieceSize + spacing,
margin + (j + 1) * pieceSize - spacing,
margin + (i + 1) * pieceSize - spacing,
outline="black", fill="blue", width=2)
elif self.game.board[i][j] == 2:
self.canvas.create_oval(margin + j * pieceSize + spacing,
margin + i * pieceSize + spacing,
margin + (j + 1) * pieceSize - spacing,
margin + (i + 1) * pieceSize - spacing,
outline="black", fill="red", width=2)
elif self.game.board[i][j] == 0:
self.canvas.create_oval(margin + j * pieceSize + spacing,
margin + i * pieceSize + spacing,
margin + (j + 1) * pieceSize - spacing,
margin + (i + 1) * pieceSize - spacing,
outline="black", fill="grey", width=2)
self.canvas.pack(fill=BOTH, expand = 1)
self.msgWindow = Entry(self.parent)
self.msgWindow.insert(0, 'Your Turn')
self.msgWindow.pack()
self.canvas.bind("<Button-1>", self.__cell_clicked)
def __repaint(self):
for i in xrange(self.game.height):
for j in xrange(self.game.mid_width_max):
if self.game.board[i][j] == 1:
self.canvas.create_oval(margin + j * pieceSize + spacing,
margin + i * pieceSize + spacing,
margin + (j + 1) * pieceSize - spacing,
margin + (i + 1) * pieceSize - spacing,
outline="black", fill="blue", width=2)
elif self.game.board[i][j] == 2:
self.canvas.create_oval(margin + j * pieceSize + spacing,
margin + i * pieceSize + spacing,
margin + (j + 1) * pieceSize - spacing,
margin + (i + 1) * pieceSize - spacing,
outline="black", fill="red", width=2)
elif self.game.board[i][j] == 0:
self.canvas.create_oval(margin + j * pieceSize + spacing,
margin + i * pieceSize + spacing,
margin + (j + 1) * pieceSize - spacing,
margin + (i + 1) * pieceSize - spacing,
outline="black", fill="grey", width=2)
def __draw_cursor(self):
self.canvas.delete("cursor")
self.canvas.delete("possible_moves")
if self.row >= 0 and self.col >= 0:
if self.game.board[self.row][self.col] == 1:
self.canvas.create_oval(margin + self.col * pieceSize + spacing,
margin + self.row * pieceSize + spacing,
margin + (self.col + 1) * pieceSize - spacing,
margin + (self.row + 1) * pieceSize - spacing,
outline="green", fill="blue", width=2, tags="cursor")
elif self.game.board[self.row][self.col] == 2:
self.canvas.create_oval(margin + self.col * pieceSize + spacing,
margin + self.row * pieceSize + spacing,
margin + (self.col + 1) * pieceSize - spacing,
margin + (self.row + 1) * pieceSize - spacing,
outline="green", fill="red", width=2, tags="cursor")
elif self.game.board[self.row][self.col] == 0:
self.canvas.create_oval(margin + self.col * pieceSize + spacing,
margin + self.row * pieceSize + spacing,
margin + (self.col + 1) * pieceSize - spacing,
margin + (self.row + 1) * pieceSize - spacing,
outline="green", fill="grey", width=2, tags="cursor")
def __draw_possible_moves(self, possibleMoves):
for (newi, newj) in possibleMoves:
if self.game.board[newi][newj] == 0:
self.canvas.create_oval(margin + newj * pieceSize + spacing,
margin + newi * pieceSize + spacing,
margin + (newj + 1) * pieceSize - spacing,
margin + (newi + 1) * pieceSize - spacing,
outline="yellow", fill="grey", width=2, tags="possible_moves")
def __cell_clicked(self, event):
x, y = event.x, event.y
if (margin < x < self.WIDTH - margin and margin < y < self.HEIGHT - margin):
self.canvas.focus_set()
# get row and col numbers from x,y coordinates
row, col = (y - margin) / pieceSize, (x - margin) / pieceSize
# if cell was selected already - deselect it
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1
#self.__draw_cursor(0)
elif self.game.board[row][col] != -1:
self.row, self.col = row, col
if (self.row, self.col) not in self.possibleMoves:
## draw selected cells
self.__draw_cursor()
## draw possible moves
if self.row != -1 and self.col != -1:
self.oldi = self.row
self.oldj = self.col
if self.turn == 1:
moves = computeLegalMoveSpecify(self.game, 1, self.row, self.col)
elif self.turn == 2:
moves = computeLegalMoveSpecify(self.game, 2, self.row, self.col)
self.possibleMoves = [(newi, newj) for (oldi, oldj, newi, newj) in moves]
print self.possibleMoves
self.__draw_possible_moves(self.possibleMoves)
else:
self.game = self.game.takeMove((self.oldi, self.oldj, self.row, self.col))
self.row, self.col = -1, -1
self.possibleMoves = []
self.turn = 3 - self.turn
msg = 'Computing'
self.msgWindow.delete(0, END)
self.msgWindow.insert(0, msg)
self.__repaint()
time.sleep(1)
if self.turn == 2:
move = findMove_Advanced(self.game, self.turn, self.weights, self.depth, self.cantGo)
print move
self.cantGo.append(move)
if (len(self.cantGo) >= 5) :
self.cantGo.pop(0)
self.game = self.game.takeMove(move)
self.__repaint()
if self.game.isEnd() == 1:
msg = 'You won!'
elif self.game.isEnd() == 2:
msg = 'You lost!'
else:
msg = 'Your Turn!'
self.msgWindow.delete(0, END)
self.msgWindow.insert(0, msg)
self.row, self.col = -1, -1
self.possibleMoves = []
self.turn = 3 - self.turn
class StudentView(Frame):
def __init__(self, parent, width, height):
#Call the initializer of the class we're inheriting from
Frame.__init__(self, parent)
self.db = SpellingDatabase()
student_list_frame = Frame(self)
self.student_listpane = ListPane(student_list_frame, height=30, width = 35)
self.student_listpane.singleClickFunc=self.display_details
sort_options_list = ['First Name', 'Last Name']
self.sort_v = StringVar()
self.sort_v.set(sort_options_list[1])
self.sort_option = OptionMenu(student_list_frame, self.sort_v, *sort_options_list, command=self.update_sort)
sort_label = Label(student_list_frame, text="Sort by:")
title_label = Label(student_list_frame, text="Student Details")
title_label.grid(row=0, column=0, sticky=W,pady=5)
self.student_listpane.grid(row=1, column=0, columnspan=2)
sort_label.grid(row=2, column=0, sticky=W, padx = 2)
self.sort_option.grid(row=2, column=0, padx=50, sticky=W)
student_details_frame=Frame(self)
fname_label = Label(student_details_frame, text="First Name:")
lname_label = Label(student_details_frame, text="Last Name:")
age_label = Label(student_details_frame, text="Birthday:")
comments_label = Label(student_details_frame, text="Comments")
self.fname_entry = Entry(student_details_frame, width=30)
self.lname_entry = Entry(student_details_frame, width=30)
self.age_entry = Entry(student_details_frame, width=30)
self.comments_text = Text(student_details_frame, width=65, height=10)
enable_edit_button = Button(student_details_frame, text="Edit Details", command=self.update_student)
add_student_button = Button(student_details_frame, text="Add Student", command=self.insert_student)
remove_student_button = Button(student_details_frame, text="Remove Student", command=self.remove_student)
fname_label.grid(row=0, column=0, sticky=W, padx=3)
lname_label.grid(row=1, column=0, sticky=W, padx=3)
age_label.grid(row=2, column=0, sticky=W, padx=3)
comments_label.grid(row=3, column=0, sticky=W, padx=3)
self.fname_entry.grid(row=0, column=1, sticky=W)
self.lname_entry.grid(row=1, column=1, sticky=W)
self.age_entry.grid(row=2, column=1, sticky=W)
self.comments_text.grid(row=4, column=0, columnspan=2, sticky=W, padx=10)
enable_edit_button.grid(row=5, column=0, padx=7)
add_student_button.grid(row=5, column=1, sticky=W)
remove_student_button.grid(row=5, column=1, sticky=W, padx=110)
student_list_frame.pack(side=LEFT)
student_details_frame.pack(side=LEFT)
#Load student table from database
student_records = self.db.sql("SELECT last_name, first_name From students ORDER By last_name")
names_list = []
for record in student_records:
names_list.append("%s, %s" % (record[0], record[1]))
self.student_listpane.display(names_list)
def update_sort(self, option):
order_by=""
if option == "First Name": order_by = 'first_name'
else: order_by = 'last_name'
student_records = self.db.sql("SELECT last_name, first_name From students ORDER By %s" % order_by)
names_list = []
for record in student_records:
if option == "First Name": names_list.append("%s %s" % (record[1], record[0]))
else: names_list.append("%s, %s" % (record[0], record[1]))
self.student_listpane.display(names_list)
def display_details(self, item_index):
if len(self.student_listpane.getDisplayed()) == 0: return
if self.fname_entry.get() == "" and self.lname_entry.get() == "": return
self.selected_student = item_index
first_name = ""
last_name = ""
if self.sort_v.get() == "First Name":
first_name, last_name = self.student_listpane.get(item_index).split(' ')
else:
last_name, first_name = self.student_listpane.get(item_index).split(', ')
student_record = self.db.sql("SELECT * from students where first_name = '%s' and last_name = '%s'" % (first_name, last_name))[0]
self.fname_entry.delete(0, END)
self.fname_entry.insert(0, first_name)
self.lname_entry.delete(0, END)
self.lname_entry.insert(0, last_name)
self.age_entry.delete(0, END)
self.age_entry.insert(0, student_record[3])
self.comments_text.delete(1.0, END)
self.comments_text.insert(1.0, student_record[4])
def remove_student(self):
if self.fname_entry.get() == "" and self.lname_entry.get() == "":
return
first_name = ""
last_name = ""
if len(self.student_listpane.get(self.selected_student))==0: return
if self.sort_v.get() == "First Name":
first_name, last_name = self.student_listpane.get(self.selected_student).split(' ')
else:
last_name, first_name = self.student_listpane.get(self.selected_student).split(', ')
self.db.sql("DELETE FROM students where first_name = '%s' and last_name = '%s'" % (first_name, last_name))
self.db.commit()
self.update_sort(self.sort_v.get())
def update_student(self):
if len(self.student_listpane.getDisplayed()) == 0: return
if self.fname_entry.get() == "" and self.lname_entry.get() == "": return
old_first_name = ""
old_last_name = ""
if self.sort_v.get() == "First Name":
old_first_name, old_last_name = self.student_listpane.get(self.selected_student).split(' ')
else:
old_last_name, old_first_name = self.student_listpane.get(self.selected_student).split(', ')
self.db.update_student(old_first_name, old_last_name, self.fname_entry.get(), self.lname_entry.get(), self.age_entry.get(), self.comments_text.get(1.0,END))
self.db.commit()
self.update_sort(self.sort_v.get())
def insert_student(self):
current_students = self.student_listpane.getDisplayed()
if self.fname_entry.get() == "" and self.lname_entry.get() == "":
return
for student in current_students:
first_name = ""
last_name = ""
if self.sort_v.get() == "First Name":
first_name, last_name = student.split(' ')
else:
last_name, first_name = student.split(', ')
if first_name == self.fname_entry.get() and last_name == self.lname_entry.get():
return
self.db.addStudent(self.fname_entry.get(), self.lname_entry.get(), self.age_entry.get(), self.comments_text.get(1.0, END))
self.db.commit()
self.update_sort(self.sort_v.get())
class LintGui(object):
"""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.visible_msgs = []
self.filenames = []
self.rating = StringVar()
self.tabs = {}
self.report_stream = BasicStream(self)
self.differ = differ.Differ()
#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)
# Binding F5 application-wide to run lint
self.root.bind('<F5>', self.run_lint)
#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.bind("<Double-Button-1>", self.show_sourcefile)
self.lbMessages.pack(expand=True, fill=BOTH)
rightscrollbar.config(command=self.lbMessages.yview)
bottomscrollbar.config(command=self.lbMessages.xview)
#Message context menu
self.mnMessages = Menu(self.lbMessages, tearoff=0)
self.mnMessages.add_command(label="View in sourcefile",
command=self.show_sourcefile)
self.mnMessages.add_command(label="Add to ignore patchfile",
command=self.add_to_ignore_patchfile)
self.lbMessages.bind("<Button-3>", self.show_messages_context)
#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)
sourceFile = Radiobutton(radio_frame,
text="Source File",
variable=self.box,
value="Source File",
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=W)
stat.grid(column=0, row=1, sticky=W)
msgCat.grid(column=1, row=1, sticky=W)
ext.grid(column=2, row=1, sticky=W)
sourceFile.grid(column=3, row=1, 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)
self.visible_msgs = []
for msg in self.msgs:
if (self.msg_type_dict.get(msg.C)()):
self.visible_msgs.append(msg)
msg_str = 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 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.C)()):
self.visible_msgs.append(msg)
msg_str = 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.visible_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='')
def show_sourcefile(self, event=None):
selected = self.lbMessages.curselection()
if not selected:
return
msg = self.visible_msgs[int(selected[0])]
scroll = msg.line - 3
if scroll < 0:
scroll = 0
self.tabs["Source File"] = open(msg.abspath, "r").readlines()
self.box.set("Source File")
self.refresh_results_window()
self.results.yview(scroll)
self.results.select_set(msg.line - 1)
def show_messages_context(self, event):
"""Show the message listbox's context menu"""
# Select the item that was clicked
index = self.lbMessages.nearest(event.y)
self.lbMessages.selection_clear(0, END)
self.lbMessages.selection_set(index)
self.lbMessages.activate(index)
self.mnMessages.tk_popup(event.x_root, event.y_root)
def add_to_ignore_patchfile(self, event=None):
"""
Add the selected message to the ignore patchfile.
This means that this message will now be ignored by pylint-patcher.
"""
selected = self.lbMessages.curselection()
if not selected:
return
selected_index = int(selected[0])
msg = self.visible_msgs[selected_index]
self.differ.add_disable_pragma(msg.abspath, msg.line, msg.symbol)
self.differ.diff()
del self.msgs[self.msgs.index(msg)]
del self.visible_msgs[selected_index]
self.lbMessages.delete(selected_index)
class Interface:
def __init__(self, master):
serverPort = 12000
clientAddress = '255.255.255.255'
serverSocket = socket(AF_INET, SOCK_DGRAM)
serverSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
serverSocket.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
serverSocket.bind(('', serverPort))
self.master = master
master.title(" DDOS ATTACK - HTTP FLOOD")
self.IP = None
self.message = "TYPE IP TO BE ATTACKED :"
self.label_text = StringVar()
self.label_text.set(self.message)
self.label = Label(master, textvariable=self.label_text,font=(None, 13),background ="black",fg ="white")
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
self.entry.configure(insertwidth=2,highlightbackground= "black")
validate_ip_args = partial(self.validate_IP, serverSocket, clientAddress, serverPort)
self.attack_button = Button(master, text="Start Attack", command=validate_ip_args, height = 2, width = 20, font=(None, 13), fg ="white", background ="black",highlightbackground= "black")
stop_attack_args = partial(self.stop_attack, serverSocket, clientAddress, serverPort)
self.stop_button = Button(master, text="Stop Attack", command=stop_attack_args, state=DISABLED, height = 2, width = 20, font=(None, 13), fg ="white", background = "black",highlightbackground= "black")
self.label.grid(row=0, column=0, columnspan=2, sticky=W+E, pady=20)
self.entry.grid(row=1, column=0, columnspan=2, sticky=W+E, pady= 8)
self.attack_button.grid(row=2, column=0, padx= 5,pady= 8)
self.stop_button.grid(row=2, column=1, padx= 5, pady= 8)
def validate(self, new_text):
if not new_text: # the field is being cleablack
self.IP = None
return True
else:
IP = new_text
self.IP=IP
return True
def validate_IP(self, serverSocket, clientAddress, serverPort):
if (is_valid_ipv4(str(self.IP))):
self.message = "VALID IP, CONTACTING SLAVES!"
serverSocket.sendto("S/"+self.IP, (clientAddress, serverPort))
self.attack_button.configure(state=DISABLED)
self.stop_button.configure(state=NORMAL)
else:
self.message = "INVALID IP, TRY AGAIN"
if self.IP is None:
self.message = "TYPE IP TO BE ATTACKED :"
self.label_text.set(self.message)
def stop_attack(self, serverSocket, clientAddress, serverPort):
self.entry.delete(0, END)
self.IP = None
serverSocket.sendto("B/", (clientAddress, serverPort))
self.message = "TYPE IP TO BE ATTACKED :"
self.label_text.set(self.message)
self.attack_button.configure(state=NORMAL)
self.stop_button.configure(state=DISABLED)
class LoginFrame(Frame):
"""Class which controls the Login and Register screens of the spelling aid"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.db = self.parent.db
#Create login screen widgets
font = ("Helvetica", 20)
self.userEntry = Entry(self.parent, width=15, font=font)
self.passEntry = Entry(self.parent, width=15, show='*', font=font)
self.passEntry.bind('<Return>', self.login)
buttonSubmit = Button(self.parent, text="Login", command=self.login, width=10)
buttonRegSwitch = Button(self.parent, text="New User",
command=self.viewRegister, width=10)
#Create register screen widgets
self.userRegEntry = Entry(self.parent, width=15, font=font)
self.passRegEntry = Entry(self.parent, width=15, show='*',
font=font)
self.passRegEntry.bind('<Return>', self.register)
buttonRegister = Button(self.parent, text="Register",
command=self.register, width=10)
buttonBack = Button(self.parent, text="Back",
command=self.viewLogin, width=10)
#Create a canvas for each screen and populate
self.login_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.register_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.login_canvas.create_text(300, 40, text="Login", font=font, fill="#004183")
self.login_canvas.create_text(170, 80, text="Username:"******"Password:"******"Register", font=font, fill="#004183")
self.register_canvas.create_text(170, 80, text="Username:"******"Password:"******"Check the user's input and allow access if it is correct"""
usernameGiven = self.userEntry.get()
passwordGiven = self.passEntry.get()
userDetails = self.db.sql("""SELECT * FROM
users WHERE username='******'"""
%(usernameGiven.lower().strip()))
#Check that the username exists
if len(userDetails)==1:
passHash = userDetails[0][2]
#Check that the password is correct
if (hashlib.sha1(passwordGiven).hexdigest() == passHash):
#Details are correct, unlock application
self.parent.login(User(userDetails[0]))
loginFailed = False
else:
loginFailed = True
else:
loginFailed = True
if loginFailed:
#If details are incorrect show an error message
tkMessageBox.showerror("Login Failed",
"Invalid username or password")
self.userEntry.delete(0, END)
self.passEntry.delete(0, END)
def register(self):
"""Register a new user with provided input"""
username = self.userRegEntry.get()
passwd = self.passRegEntry.get()
if username != '' and passwd != '':
username = username.lower().strip()
passHash = hashlib.sha1(passwd).hexdigest()
self.db.sql("""INSERT INTO users (username, passwd) VALUES
('%s', '%s')"""%(username, passHash))
self.viewLogin()
def viewRegister(self):
"""Switch to the register screen"""
self.login_canvas.pack_forget()
self.register_canvas.pack()
def viewLogin(self):
"""Switch to the login screen"""
self.register_canvas.pack_forget()
self.login_canvas.pack()
text="Question:",
bg="#99ccff",
fg='blue4',
bd=20,
anchor='w').grid(row=1, column=0, sticky=E, pady=(0, 0))
#function to show and print question
entry = Entry(form,
font=('arial', 10, 'bold'),
width=120,
bd=13,
bg="#99ccff",
fg="#012b74")
entry.fieldname = "Question"
entry.grid(row=1, column=1, sticky=E + W)
entry.delete(0, END)
str3 = generateQuestion()
entry.insert(0, (str3))
Label(form,
font=('arial', 12, 'bold'),
text="Answer write here:",
bg="#99ccff",
fg="#012b74",
bd=10,
anchor='w').grid(row=5, column=0, sticky=E, pady=(8, 2))
text1 = Text(form,
font=('arial', 12, 'bold'),
height=2,
fg="#012b74",
bg="#99ccff",
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 ConcordanceSearchView(object):
_BACKGROUND_COLOUR='#FFF' #white
#Colour of highlighted results
_HIGHLIGHT_WORD_COLOUR='#F00' #red
_HIGHLIGHT_WORD_TAG='HL_WRD_TAG'
_HIGHLIGHT_LABEL_COLOUR='#C0C0C0' # dark grey
_HIGHLIGHT_LABEL_TAG='HL_LBL_TAG'
#Percentage of text left of the scrollbar position
_FRACTION_LEFT_TEXT=0.30
def __init__(self):
self.model = ConcordanceSearchModel()
self.model.add_listener(self)
self.top = Tk()
self._init_top(self.top)
self._init_menubar()
self._init_widgets(self.top)
self._bind_event_handlers()
self.load_corpus(self.model.DEFAULT_CORPUS)
def _init_top(self, top):
top.geometry('950x680+50+50')
top.title('NLTK Concordance Search')
top.bind('<Control-q>', self.destroy)
top.minsize(950,680)
def _init_widgets(self, parent):
self.main_frame = Frame(parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1))
self._init_corpus_select(self.main_frame)
self._init_query_box(self.main_frame)
self._init_results_box(self.main_frame)
self._init_paging(self.main_frame)
self._init_status(self.main_frame)
self.main_frame.pack(fill='both', expand=True)
def _init_menubar(self):
self._result_size = IntVar(self.top)
self._cntx_bf_len = IntVar(self.top)
self._cntx_af_len = IntVar(self.top)
menubar = Menu(self.top)
filemenu = Menu(menubar, tearoff=0, borderwidth=0)
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-q')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
rescntmenu = Menu(editmenu, tearoff=0)
rescntmenu.add_radiobutton(label='20', variable=self._result_size,
underline=0, value=20,
command=self.set_result_size)
rescntmenu.add_radiobutton(label='50', variable=self._result_size,
underline=0, value=50,
command=self.set_result_size)
rescntmenu.add_radiobutton(label='100', variable=self._result_size,
underline=0, value=100,
command=self.set_result_size)
rescntmenu.invoke(1)
editmenu.add_cascade(label='Result Count', underline=0, menu=rescntmenu)
cntxmenu = Menu(editmenu, tearoff=0)
cntxbfmenu = Menu(cntxmenu, tearoff=0)
cntxbfmenu.add_radiobutton(label='60 characters',
variable=self._cntx_bf_len,
underline=0, value=60,
command=self.set_cntx_bf_len)
cntxbfmenu.add_radiobutton(label='80 characters',
variable=self._cntx_bf_len,
underline=0, value=80,
command=self.set_cntx_bf_len)
cntxbfmenu.add_radiobutton(label='100 characters',
variable=self._cntx_bf_len,
underline=0, value=100,
command=self.set_cntx_bf_len)
cntxbfmenu.invoke(1)
cntxmenu.add_cascade(label='Before', underline=0, menu=cntxbfmenu)
cntxafmenu = Menu(cntxmenu, tearoff=0)
cntxafmenu.add_radiobutton(label='70 characters',
variable=self._cntx_af_len,
underline=0, value=70,
command=self.set_cntx_af_len)
cntxafmenu.add_radiobutton(label='90 characters',
variable=self._cntx_af_len,
underline=0, value=90,
command=self.set_cntx_af_len)
cntxafmenu.add_radiobutton(label='110 characters',
variable=self._cntx_af_len,
underline=0, value=110,
command=self.set_cntx_af_len)
cntxafmenu.invoke(1)
cntxmenu.add_cascade(label='After', underline=0, menu=cntxafmenu)
editmenu.add_cascade(label='Context', underline=0, menu=cntxmenu)
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
self.top.config(menu=menubar)
def set_result_size(self, **kwargs):
self.model.result_count = self._result_size.get()
def set_cntx_af_len(self, **kwargs):
self._char_after = self._cntx_af_len.get()
def set_cntx_bf_len(self, **kwargs):
self._char_before = self._cntx_bf_len.get()
def _init_corpus_select(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.var = StringVar(innerframe)
self.var.set(self.model.DEFAULT_CORPUS)
Label(innerframe, justify=LEFT, text=' Corpus: ',
background=self._BACKGROUND_COLOUR, padx = 2, pady = 1, border = 0).pack(side='left')
other_corpora = self.model.CORPORA.keys().remove(self.model.DEFAULT_CORPUS)
om = OptionMenu(innerframe, self.var, self.model.DEFAULT_CORPUS, command=self.corpus_selected, *self.model.non_default_corpora())
om['borderwidth'] = 0
om['highlightthickness'] = 1
om.pack(side='left')
innerframe.pack(side='top', fill='x', anchor='n')
def _init_status(self, parent):
self.status = Label(parent, justify=LEFT, relief=SUNKEN, background=self._BACKGROUND_COLOUR, border=0, padx = 1, pady = 0)
self.status.pack(side='top', anchor='sw')
def _init_query_box(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
another = Frame(innerframe, background=self._BACKGROUND_COLOUR)
self.query_box = Entry(another, width=60)
self.query_box.pack(side='left', fill='x', pady=25, anchor='center')
self.search_button = Button(another, text='Search', command=self.search, borderwidth=1, highlightthickness=1)
self.search_button.pack(side='left', fill='x', pady=25, anchor='center')
self.query_box.bind('<KeyPress-Return>', self.search_enter_keypress_handler)
another.pack()
innerframe.pack(side='top', fill='x', anchor='n')
def search_enter_keypress_handler(self, *event):
self.search()
def _init_results_box(self, parent):
innerframe = Frame(parent)
i1 = Frame(innerframe)
i2 = Frame(innerframe)
vscrollbar = Scrollbar(i1, borderwidth=1)
hscrollbar = Scrollbar(i2, borderwidth=1, orient='horiz')
self.results_box = Text(i1,
font=tkFont.Font(family='courier', size='16'),
state='disabled', borderwidth=1,
yscrollcommand=vscrollbar.set,
xscrollcommand=hscrollbar.set, wrap='none', width='40', height = '20', exportselection=1)
self.results_box.pack(side='left', fill='both', expand=True)
self.results_box.tag_config(self._HIGHLIGHT_WORD_TAG, foreground=self._HIGHLIGHT_WORD_COLOUR)
self.results_box.tag_config(self._HIGHLIGHT_LABEL_TAG, foreground=self._HIGHLIGHT_LABEL_COLOUR)
vscrollbar.pack(side='left', fill='y', anchor='e')
vscrollbar.config(command=self.results_box.yview)
hscrollbar.pack(side='left', fill='x', expand=True, anchor='w')
hscrollbar.config(command=self.results_box.xview)
#there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
Label(i2, text=' ', background=self._BACKGROUND_COLOUR).pack(side='left', anchor='e')
i1.pack(side='top', fill='both', expand=True, anchor='n')
i2.pack(side='bottom', fill='x', anchor='s')
innerframe.pack(side='top', fill='both', expand=True)
def _init_paging(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.prev = prev = Button(innerframe, text='Previous', command=self.previous, width='10', borderwidth=1, highlightthickness=1, state='disabled')
prev.pack(side='left', anchor='center')
self.next = next = Button(innerframe, text='Next', command=self.next, width='10', borderwidth=1, highlightthickness=1, state='disabled')
next.pack(side='right', anchor='center')
innerframe.pack(side='top', fill='y')
self.current_page = 0
def previous(self):
self.clear_results_box()
self.freeze_editable()
self.model.prev(self.current_page - 1)
def next(self):
self.clear_results_box()
self.freeze_editable()
self.model.next(self.current_page + 1)
def about(self, *e):
ABOUT = ("NLTK Concordance Search Demo\n")
TITLE = 'About: NLTK Concordance Search Demo'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE, parent=self.main_frame).show()
except:
ShowText(self.top, TITLE, ABOUT)
def _bind_event_handlers(self):
self.top.bind(CORPUS_LOADED_EVENT, self.handle_corpus_loaded)
self.top.bind(SEARCH_TERMINATED_EVENT, self.handle_search_terminated)
self.top.bind(SEARCH_ERROR_EVENT, self.handle_search_error)
self.top.bind(ERROR_LOADING_CORPUS_EVENT, self.handle_error_loading_corpus)
def handle_error_loading_corpus(self, event):
self.status['text'] = 'Error in loading ' + self.var.get()
self.unfreeze_editable()
self.clear_all()
self.freeze_editable()
def handle_corpus_loaded(self, event):
self.status['text'] = self.var.get() + ' is loaded'
self.unfreeze_editable()
self.clear_all()
self.query_box.focus_set()
def handle_search_terminated(self, event):
#todo: refactor the model such that it is less state sensitive
results = self.model.get_results()
self.write_results(results)
self.status['text'] = ''
if len(results) == 0:
self.status['text'] = 'No results found for ' + self.model.query
else:
self.current_page = self.model.last_requested_page
self.unfreeze_editable()
self.results_box.xview_moveto(self._FRACTION_LEFT_TEXT)
def handle_search_error(self, event):
self.status['text'] = 'Error in query ' + self.model.query
self.unfreeze_editable()
def corpus_selected(self, *args):
new_selection = self.var.get()
self.load_corpus(new_selection)
def load_corpus(self, selection):
if self.model.selected_corpus != selection:
self.status['text'] = 'Loading ' + selection + '...'
self.freeze_editable()
self.model.load_corpus(selection)
def search(self):
self.current_page = 0
self.clear_results_box()
self.model.reset_results()
query = self.query_box.get()
if (len(query.strip()) == 0): return
self.status['text'] = 'Searching for ' + query
self.freeze_editable()
self.model.search(query, self.current_page + 1, )
def write_results(self, results):
self.results_box['state'] = 'normal'
row = 1
for each in results:
sent, pos1, pos2 = each[0].strip(), each[1], each[2]
if len(sent) != 0:
if (pos1 < self._char_before):
sent, pos1, pos2 = self.pad(sent, pos1, pos2)
sentence = sent[pos1-self._char_before:pos1+self._char_after]
if not row == len(results):
sentence += '\n'
self.results_box.insert(str(row) + '.0', sentence)
word_markers, label_markers = self.words_and_labels(sent, pos1, pos2)
for marker in word_markers: self.results_box.tag_add(self._HIGHLIGHT_WORD_TAG, str(row) + '.' + str(marker[0]), str(row) + '.' + str(marker[1]))
for marker in label_markers: self.results_box.tag_add(self._HIGHLIGHT_LABEL_TAG, str(row) + '.' + str(marker[0]), str(row) + '.' + str(marker[1]))
row += 1
self.results_box['state'] = 'disabled'
def words_and_labels(self, sentence, pos1, pos2):
search_exp = sentence[pos1:pos2]
words, labels = [], []
labeled_words = search_exp.split(' ')
index = 0
for each in labeled_words:
if each == '':
index += 1
else:
word, label = each.split('/')
words.append((self._char_before + index, self._char_before + index + len(word)))
index += len(word) + 1
labels.append((self._char_before + index, self._char_before + index + len(label)))
index += len(label)
index += 1
return words, labels
def pad(self, sent, hstart, hend):
if hstart >= self._char_before:
return sent, hstart, hend
d = self._char_before - hstart
sent = ''.join([' '] * d) + sent
return sent, hstart + d, hend + d
def destroy(self, *e):
if self.top is None: return
self.top.destroy()
self.top = None
def clear_all(self):
self.query_box.delete(0, END)
self.model.reset_query()
self.clear_results_box()
def clear_results_box(self):
self.results_box['state'] = 'normal'
self.results_box.delete("1.0", END)
self.results_box['state'] = 'disabled'
def freeze_editable(self):
self.query_box['state'] = 'disabled'
self.search_button['state'] = 'disabled'
self.prev['state'] = 'disabled'
self.next['state'] = 'disabled'
def unfreeze_editable(self):
self.query_box['state'] = 'normal'
self.search_button['state'] = 'normal'
self.set_paging_button_states()
def set_paging_button_states(self):
if self.current_page == 0 or self.current_page == 1:
self.prev['state'] = 'disabled'
else:
self.prev['state'] = 'normal'
if self.model.has_more_pages(self.current_page):
self.next['state'] = 'normal'
else:
self.next['state'] = 'disabled'
def fire_event(self, event):
#Firing an event so that rendering of widgets happen in the mainloop thread
self.top.event_generate(event, when='tail')
def mainloop(self, *args, **kwargs):
if in_idle(): return
self.top.mainloop(*args, **kwargs)
