def __init__(self, tkRoot, app, masterComp, parentNode, logger):
BaseView.__init__(self, tkRoot, app, logger)
# master (upper level view) component on which this view was issued
self.masterComp = masterComp
self.parentNode = parentNode
self.window = Toplevel(self.tkRoot)
self.window.title("%s" % parentNode.keyForIsObject)
# self.window.bind("<<close-window>>", self.__onClose) # doesn't work
self.window.protocol("WM_DELETE_WINDOW", self.__onClose)
text = ScrolledText(self.window, width = RobView.GUI_WIDTH,
height = RobView.GUI_HEIGHT, background='white')
text.pack(fill = Y)
# information from ROB (DataChannel) IS object (criteria results)
# .valueOfIsObject is a bit misleading since it's criteria results
# checks based on particular values (attributes) within the IS object
m = ("ROB '%s':\n\n%s" %
(parentNode.keyForIsObject, parentNode.valueOfIsObject))
text.insert(END, m)
text.configure(state = DISABLED) # disable edit now, not before insert
# need to store this view under full name (not only under
# self.masterComp.name as the other views), since there may be
# a number of views named e.g. 'DataChannel0'
self.app.addActiveView(self.parentNode.keyForIsObject, self)
class Credits(tkSimpleDialog.Dialog):
def body(self, master):
self.image = Tk.PhotoImage(file=GIFFILE)
self.icon = Tk.Label(master, image=self.image)
self.icon.pack(side=Tk.TOP)
label = Tk.Label(master, text=crnotice1)
label.pack(side=Tk.TOP)
font = "Helvetica " + TITLEFONTSIZE
label = Tk.Label(master,
font=font,
text="Credits",
justify=Tk.CENTER,
foreground='blue')
label.pack(side=Tk.TOP)
font = "Helvetica " + AXISFONTSIZE
self.infoText = ScrolledText(master,
relief=Tk.FLAT,
padx=3,
pady=3,
background='white',
foreground="blue",
wrap='word',
width=70,
height=12,
font=font,
tabs=("4c"))
self.infoText.pack(expand=0, fill=Tk.X, side=Tk.BOTTOM)
self.infoText.delete('0.0', Tk.END)
self.infoText.insert('0.0', getCredits())
self.infoText.configure(state=Tk.DISABLED)
class TraceFrame(Frame):
def __init__(self, *args, **kwargs):
Frame.__init__(self, *args, **kwargs)
self.t = ScrolledText(self, wrap="word")
self.t.configure(background="light cyan")
self.t.configure(height = 10)
self.t.tag_config("in", foreground="forest green")
self.t.tag_config("err", foreground="orange red")
self.t.tag_config("time", foreground="sea green")
self.t.tag_config("curr", foreground="black")
self.t.tag_config("out", foreground="firebrick")
self.t.pack(side="top", fill="both", expand=True)
def add_To_Trace(self, st, tag):
'''
:param st: txte a afficher
:param tag: type de texte a afficher
:return:
'''
self.t.insert(INSERT, st, tag)
self.t.see(END)
def clear_Trace(self):
'''
Efface la zone de texte
:return:
'''
self.t.delete('1.0', 'end')
class Run_UI:
def __init__(self,root):
#creating the title and window dimensions
root.iconbitmap('Images\img.ico')
root.title("Never Miss Class")
root.maxsize(width=450,height=300)
root.minsize(width=450,height=300)
centre_screen(root,225,150)
#creating a canvas to place widgets on
self.main_canvas = Canvas(root,width = 450, height =300,highlightthickness=0)
self.main_canvas.pack()
self.text_field = ScrolledText(self.main_canvas,width=52,height=18)
#You have to set the state to normal to make changes to it. Disabling it makes it uneditable
self.text_field.configure(state='normal')
#deleting anything previously in the text field
self.text_field.delete(1.0,END)
#putting stuff in the text field. Works just like appending onto a list.
self.text_field.insert(END, "The program is now running in the background. \n")
#open the current day's database file
today = datetime.datetime.now().weekday()
weekdays = {0:"Monday",1:"Tuesday",2:"Wednesday",3:"Thursday",4:"Friday"}
f = open(weekdays[today]+".txt", "r")
classes = []
for line in f:
classes.append(line.strip("\n").split("|"))
f.close()
# sort the 2d list by class times, and sort the class names and URLs
# in the same way so the times and names stay together
insert_sort(classes[1], classes[0], classes[2])
# set up default names for any classes the user has not named
for i in range(len(classes[2])):
if classes[2][i] == "":
classes[2][i] = "Class " + str(i)
# print out the sorted schedule
self.text_field.insert(END, "Here is "+weekdays[today]+"'s schedule: \n")
self.text_field.insert(END, ("{0:25}{1:>10}").format("Class Name", "Class Time \n"))
self.text_field.insert(END, "-" * 35 + "\n")
# iterate through the list of URLs
for i in range(len(classes[0])):
# for every non-empty url, print the associated name and date of the class
if classes[0][i] != "":
self.text_field.insert(END, ("{0:25}{1:>10}").format(classes[2][i], classes[1][i] + "\n"))
# disable the text field after writing to it
self.text_field.configure(state='disabled')
self.text_field.place(x=5,y=5)
def build_dlg(self):
top = self.top
top.resizable(0, 1)
frame = Tkinter.Frame(top)
text = ScrolledText(frame, height=13, width=50, background='white')
text.insert('1.0', self.help_text)
text.configure(state='disabled')
text.grid(column=0, row=0, sticky='nesw')
frame.columnconfigure(0, weight=1)
frame.rowconfigure(0, weight=1)
button = Tkinter.Button(frame, text=_('Close'), command=self.cancel)
button.grid(column=0, row=1)
frame.pack(expand=1, fill='both')
class aAbout(tkSimpleDialog.Dialog):
""" The application's about box """
def __init__(self, master=None):
tkSimpleDialog.Dialog.__init__(self, master)
def buttonbox(self):
# Stolen from tkSimpleDialog.py
# add standard button box. override if you don't want the
# standard buttons
box = Tk.Frame(self)
w = Tk.Button(box, text="OK", width=10)
w.pack(side=Tk.RIGHT, padx=5, pady=5)
self.bind("<Return>", self.ok)
box.pack(side=Tk.BOTTOM, fill=X)
def body(self, master):
self.resizable(0, 0)
self.catIconImage = Tk.PhotoImage(file=GIFFILE) # statt file=
self.catIcon = Tk.Label(master, image=self.catIconImage)
self.catIcon.pack(side=Tk.TOP)
label = Tk.Label(master, text=crnotice1)
label.pack(side=Tk.TOP)
font = "Helvetica " + TITLEFONTSIZE
label = Tk.Label(master, font=font, text=crnotice2, justify=Tk.CENTER)
label.pack(side=Tk.TOP)
color = 'green'
font = "Helvetica " + AXISFONTSIZE
self.infoText = ScrolledText(
master,
relief=Tk.FLAT,
padx=3,
pady=3,
background=color,
#foreground="black",
wrap='word',
width=60,
height=12,
font=font)
self.infoText.pack(expand=0, fill=X, side=Tk.BOTTOM)
self.infoText.delete('0.0', Tk.END)
self.infoText.insert('0.0', getLicense())
self.infoText.configure(state=Tk.DISABLED)
self.title("STARS - About")
def ok(self):
print 'ok'
class aAbout(tkSimpleDialog.Dialog):
""" The application's about box """
def __init__(self, master=None):
tkSimpleDialog.Dialog.__init__(self, master)
def buttonbox(self):
# Stolen from tkSimpleDialog.py
# add standard button box. override if you don't want the
# standard buttons
box = Tk.Frame(self)
w = Tk.Button(box, text="OK", width=10)
w.pack(side=Tk.RIGHT, padx=5, pady=5)
self.bind("<Return>", self.ok)
box.pack(side=Tk.BOTTOM,fill=X)
def body(self, master):
self.resizable(0,0)
self.catIconImage = Tk.PhotoImage(file=GIFFILE) # statt file=
self.catIcon = Tk.Label(master, image=self.catIconImage)
self.catIcon.pack(side=Tk.TOP)
label = Tk.Label(master, text=crnotice1)
label.pack(side=Tk.TOP)
font = "Helvetica "+TITLEFONTSIZE
label = Tk.Label(master, font=font, text=crnotice2,
justify=Tk.CENTER)
label.pack(side=Tk.TOP)
color = 'green'
font = "Helvetica "+AXISFONTSIZE
self.infoText = ScrolledText(master, relief=Tk.FLAT,
padx=3, pady=3,
background=color,
#foreground="black",
wrap='word',
width=60, height=12,
font=font)
self.infoText.pack(expand=0, fill=X, side=Tk.BOTTOM)
self.infoText.delete('0.0', Tk.END)
self.infoText.insert('0.0', getLicense())
self.infoText.configure(state=Tk.DISABLED)
self.title("STARS - About")
def ok(self):
print 'ok'
class Licensing( Frame ):
BUTTON_TEXT = "Copy to clipboard"
def __init__( self, master ):
Frame.__init__( self, master )
COMPOSITOR.register_view( self )
self._setup_view()
self.on_model_updated( COMPOSITOR.OTHER_UPDATED )
def _setup_view( self ):
self.rowconfigure( 0, weight = 1 )
self.columnconfigure( 0, weight = 1 )
self.license_box = ScrolledText( self, state = DISABLED )
self.license_box.grid( row = 0, column = 0, sticky = W + E + N + S, padx = 5, pady = 5 )
self.clipboard_button = Button( self, text = self.BUTTON_TEXT, command = self._on_copy_pressed )
self.clipboard_button.grid( row = 1, column = 0, sticky = N + E )
def _on_copy_pressed( self ):
self.license_box.clipboard_clear()
self.license_box.clipboard_append( self.license_box.get( '0.0', END ) )
self.clipboard_button.configure( text = "Copied!", state = DISABLED )
self.after( 2500, lambda: self.clipboard_button.configure( text = self.BUTTON_TEXT, state = NORMAL ) )
def on_model_updated( self, reason ):
if reason not in [COMPOSITOR.OTHER_UPDATED, COMPOSITOR.SELECTED_TYPE_CHANGED, COMPOSITOR.LAYER_ADDED, COMPOSITOR.LAYER_REMOVED, COMPOSITOR.SHEET_SELECTED, COMPOSITOR.LAYER_ORDER_CHANGED]:
return
# The compositor changed state, so make sure we're up to date, too.
self.license_box.configure( state = NORMAL )
# clear the existing text
self.license_box.delete( 1.0, END )
sheets = COMPOSITOR.get_selected_sheets().values()
license_text = LICENSING.get_formatted_licensing( sheets )
self.license_box.insert( END, license_text )
self.license_box.configure( state = DISABLED )
def destroy( self ):
COMPOSITOR.deregister_view( self )
Frame.destroy( self )
class Credits(tkSimpleDialog.Dialog):
def body(self, master):
self.image = Tk.PhotoImage(file=GIFFILE)
self.icon = Tk.Label(master, image=self.image)
self.icon.pack(side=Tk.TOP)
label = Tk.Label(master, text= crnotice1)
label.pack(side=Tk.TOP)
font = "Helvetica "+TITLEFONTSIZE
label = Tk.Label(master, font=font,text= "Credits",
justify=Tk.CENTER, foreground='blue')
label.pack(side=Tk.TOP)
font = "Helvetica "+AXISFONTSIZE
self.infoText = ScrolledText(master, relief=Tk.FLAT,
padx=3, pady=3,
background='white',
foreground="blue",
wrap='word',
width=70, height=12,
font=font,
tabs=("4c"))
self.infoText.pack(expand=0, fill=Tk.X, side=Tk.BOTTOM)
self.infoText.delete('0.0', Tk.END)
self.infoText.insert('0.0', getCredits())
self.infoText.configure(state=Tk.DISABLED)
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect((host, 8090))
except:
print "Connection Failed. Please try again later"
sys.exit()
# The following is the gui programming part to create a
# window to display the incoming messages, and accept user input to send to
# chat server
root = Tk()
root.title("Admin Client v.0.1")
# Display textbox (15 rows by 80 columns)
displayT = ScrolledText(root, height=15, width=80)
displayT.insert(END, "")
displayT.configure(state="disabled")
displayT.pack()
# User input textbox (at the lower part of the window, only 2 rows x 80 column)
inputT = Text(root, height=2, width=80, bg='#ffa64d')
inputT.insert(END, "")
inputT.bind('<KeyRelease>', inputKeyup)
inputT.pack(side=LEFT)
sendbutton = Button(root, text="Send")
sendbutton.bind('<Button-1>', sendmsg)
sendbutton.pack()
quitbutton = Button(root, text="Quit")
quitbutton.bind('<Button-1>', quit)
quitbutton.pack()
inputT.focus_set() # ensure focus on the input textbox
fd.close()
return blks
root = Tk()
root.configure(background='black')
root.title("Merge Join Algorithm with Given Queries")
root.resizable(width=False, height=False)
frame = Frame(root)
queryvar = StringVar()
ql = StringVar()
frame.grid(row=2, column=0, columnspan=4)
text = ScrolledText(frame, wrap="word")
text.grid(row=2)
text.config(font=("Courier", 12))
text.configure(background='white', foreground='black')
d = "C:/Users/skuch/Desktop/Courses/8340_DB2/Project/Tables/"
branchNYC = readBlocks(d + "NewYork_Branch.txt", 7)
text.insert(INSERT, "\n")
#text.insert(INSERT, len(branchNYC))
accountNYC = readBlocks(d + 'NewYork_Account.txt', 10)
text.insert(INSERT, "\n")
#text.insert(INSERT, len(accountNYC))
depositorNYC = readBlocks(d + 'NewYork_Depositor.txt', 15)
text.insert(INSERT, "\n")
#text.insert(INSERT, len(depositorNYC))
customerHOU = readBlocks(d + 'Houston_Customer.txt', 8)
text.insert(INSERT, "\n")
def build_dlg(self):
from Sketch.Plugins.Objects.Lib.autoshapes.icons import icons
top = self.top
frame = Tkinter.Frame(top)
text = ScrolledText(frame, background='#ffffff', height=10, width=40)
self.text = text
def NOOP():
pass
def add(text, bitmap, fun=NOOP):
button = ShapeBtn(text, bitmap)
button.config(command=fun)
text.window_create("end", window=button)
def newline(text):
pass
#text.insert('end', '\n')
add(text, icons.uparrow, lambda s=self: s.insert('arrow', 270))
add(text, icons.rightarrow, lambda s=self: s.insert('arrow', 180))
add(text, icons.downarrow, lambda s=self: s.insert('arrow', 90))
add(text, icons.leftarrow, lambda s=self: s.insert('arrow', 0))
newline(text)
add(text, icons.vdoublearrow, lambda s=self: \
s.insert('doublearrow', 90))
add(text, icons.hdoublearrow, lambda s=self: \
s.insert('doublearrow', 0))
newline(text)
add(text, icons.thinleftturn1, lambda s=self: s.insert('thinturn'))
add(text, icons.thinrightturn1, lambda s=self: \
s.insert('thinturn', 180))
add(text, icons.thinleftturn2, lambda s=self: \
s.insert_toggle_dir('thinturn'))
add(text, icons.thinrightturn2, lambda s=self: \
s.insert_toggle_dir('thinturn', 180))
add(text, icons.leftthinhalfturn, lambda s=self: \
s.insert('thinhalfturn'))
add(text, icons.rightthinhalfturn, lambda s=self: \
s.insert('thinhalfturn', 180))
newline(text)
add(text, icons.scalebar, lambda s=self: s.insert('scalebar'))
add(text, icons.happy, lambda s=self: s.insert('smiley'))
add(text, icons.sad, lambda s=self: s.insert_sad())
newline(text)
add(text, icons.cube, lambda s=self: s.insert('cube'))
add(text, icons.cylinder, lambda s=self: s.insert('cylinder'))
add(text, icons.triangle, lambda s=self: s.insert_triangle())
add(text, icons.hexagon, lambda s=self: s.insert_hexagon())
newline(text)
add(text, icons.star1, lambda s=self: s.insert_star(10, 20, 6))
add(text, icons.star2, lambda s=self: s.insert_star(15, 20, 6))
add(text, icons.star3, lambda s=self: s.insert_star(5, 20, 8))
newline(text)
add(text, icons.angle, lambda s=self: s.insert('angle'))
add(text, icons.measure, lambda s=self: s.insert('measure'))
#add(text, icons.roundedangle, lambda s=self:s.insert('roundedangle'))
add(text, icons.raster, lambda s=self: s.insert('raster'))
add(text, icons.tangent, lambda s=self: s.insert('tangent'))
add(text, icons.divide, lambda s=self: s.insert('divide'))
add(text, icons.intersection, lambda s=self: s.insert('intersection'))
newline(text)
add(text, icons.circle1, lambda s=self: s.insert('circle1'))
add(text, icons.circle2, lambda s=self: s.insert('circle2'))
add(text, icons.circle3, lambda s=self: s.insert('circle3'))
add(text, icons.arc, lambda s=self: s.insert('arc'))
add(text, icons.rim, lambda s=self: s.insert('rim'))
newline(text)
add(text, icons.vconnection, lambda s=self: s.insert('vconnection'))
add(text, icons.hconnection, lambda s=self: s.insert('hconnection'))
add(text, icons.dconnection, lambda s=self: s.insert('dconnection'))
newline(text)
text.configure(state='disabled')
text.grid(column=0, row=0, sticky='ewns')
frame.rowconfigure(0, weight=1)
frame.columnconfigure(0, weight=1)
bottom = Tkinter.Frame(frame)
button = Tkinter.Button(bottom, text=_('Close'), \
command=self.close_dlg)
button.pack(side='right')
if _debug:
button = Tkinter.Button(bottom, text=_('Shell'), \
command=self.open_shell)
button.pack(side='left')
bottom.grid(column=0, row=1, sticky='ew')
frame.pack(fill='both', expand=1)
self.frame = frame
class gui:
def __init__(self):
self.master = Tk()
self.master.geometry("800x600+100+10")
self.master.title("WIReS - Web Information Retrieval System")
self.master.configure(background='white')
self.master.resizable(width=FALSE, height=FALSE)
########################################################################################################
def guimain(self):
global query
query = StringVar(None)
def devs():
tkMessageBox.showinfo("DEVELOPERS", '''BS COMPUTER SCIENCE 302
CAVITE STATE UNIVERSITY - ROSARIO CAMPUS
Lamberto A. Bruno. Jr.
Jomari R. Iringan
''')
def help():
tkMessageBox.showinfo("HELP", '''CONTACT US:
Bruno ( 0905-511-9881 )
Joms ( 0906-870-2976 )
EMAIL US:
[email protected]
''')
def priv():
tkMessageBox.showinfo("PRIVACY", '''For privacy terms and policies please see
https://www.google.com/policies/privacy/
''')
def clearBtn():
self.searchEntry.delete(0,END)
self.searchEntry.focus_set()
return
self.label1 = Label(self.master, text="WIReS", font=('Impact',70),bg='white')
self.label2 = Label(self.master, text=" SEARCH ENGINE", bg ='#008080', fg='white', font=('arial',7))
self.lineLabel = Label(self.master,text="____________________________",fg='red',bg='red', font =('arial',7))
self.helpBtn = Button(self.master, text="HELP", font=('Courier',10),command = help)
self.privBtn = Button(self.master, text="PRIVACY", font=('Courier',10),command = priv)
self.devsBtn = Button(self.master, text="DEVS", font=('Courier',10),command = devs)
self.searchEntry = Entry(self.master, width='50', relief='groove', borderwidth='5', font=('Calibri',15), textvariable=query)
self.searchButton = Button(self.master, text="SEARCH!", width='30')
self.clearButton = Button(self.master, text="CLEAR FIELD", command = clearBtn)
#locs
self.label1.place(x=300,y=150)
self.label2.place(x=455,y=250)
self.lineLabel.place(x=310,y=250)
self.searchEntry.place(x=180,y=320)
self.searchButton.place(x=400,y=400)
self.clearButton.place(x=250, y=400)
self.devsBtn.place(x=690,y=570)
self.helpBtn.place(x=738,y=570)
self.privBtn.place(x=618, y=570)
self.searchEntry.focus_set()
self.searchButton.bind("<Button-1>",self.searchBtn)
self.searchEntry.bind("<Return>", self.searchBtn)
def searchBtn(self, event):
try:
global xTime
global query
xTime = StringVar()
query = StringVar(None)
search_ = Search()
query = self.searchEntry.get()
if query not in (None, '', ' '):
start_time = time.time()
global title_url
title_url = [None]
raw = search_.fetch_url(query)
title_url = search_.process_url(raw)
self.master.withdraw()
xTime = (time.time() - start_time)
self.guiresults()
else:
tkMessageBox.showinfo('Info', 'You must put a keyword')
except Exception as e:
tkMessageBox.showinfo('Info', 'No Internet Connection Try Again Later')
exit()
####################
def guiresults(self):
global q_String
q_String = StringVar()
graph = Graph()
html_parse = htmlParser()
def showGraph():
raws = StringVar()
raws = self.result_label.get(1.0, END)
graph.plot_word(raws)
def showPos():
raws = StringVar()
raws = self.result_label.get(1.0, END)
graph.plot_pos(raws)
def clearBtn1():
self.searchEntry1.delete(0,END)
self.searchEntry1.focus_set()
return
start_time = time.time()
self.masters = Tk()
self.masters.geometry("1100x700+100+10")
self.masters.title("WIReS - Web Information Retrieval System")
self.masters.configure(background='white')
self.masters.resizable(width=FALSE, height=FALSE)
self.searchEntry1 = Entry(self.masters, width='50', relief='groove', borderwidth='5', font=('Calibri',15))
self.searchButton = Button(self.masters, text="SEARCH!", width='25')
self.clearButton1 = Button(self.masters, text="CLEAR FIELD", width='25',command = clearBtn1)
self.labelss = Label(self.masters, text="SEARCH RESULTS:", bg ='#008080', fg='white', font=('arial',10))
self.timeLabel = Label(self.masters, text="SEARCH COMPLETED AT ", font=('arial',8))
self.resultframe = LabelFrame(self.masters,text="PAGE RESULT",height=520, width=990,relief = "groove", bg ="white")
self.resultframe1 = LabelFrame(self.masters,height=540, width=990,relief = "groove", bg ="white")
self.result_label = ScrolledText(self.resultframe,width = 120, height = 32,bg = 'white', undo = True)
self.graphButton = Button(self.masters, text="WORD OCCURENCE(GRAPH)", width='25',command = showGraph)
self.posButton = Button(self.masters, text="PART OF SPEECH(GRAPH)", width='25', command = showPos)
#URL
self.labelres1 = Label(self.resultframe1, text = title_url[0][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres1= Label(self.resultframe1, text = title_url[0][1], fg="blue", cursor="hand2", bg="white")
self.labelres2 = Label(self.resultframe1, text = title_url[1][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres2 = Label(self.resultframe1, text = title_url[1][1], fg="blue", cursor="hand2", bg="white")
self.labelres3 = Label(self.resultframe1, text = title_url[2][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres3 = Label(self.resultframe1, text = title_url[2][1], fg="blue", cursor="hand2", bg="white")
self.labelres4 = Label(self.resultframe1, text = title_url[3][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres4 = Label(self.resultframe1, text = title_url[3][1], fg="blue", cursor="hand2", bg="white")
self.labelres5 = Label(self.resultframe1, text = title_url[4][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres5 = Label(self.resultframe1, text = title_url[4][1], fg="blue", cursor="hand2", bg="white")
self.labelres6 = Label(self.resultframe1, text = title_url[5][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres6 = Label(self.resultframe1, text = title_url[5][1], fg="blue", cursor="hand2", bg="white")
self.labelres7 = Label(self.resultframe1, text = title_url[6][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres7 = Label(self.resultframe1, text = title_url[6][1], fg="blue", cursor="hand2", bg="white")
self.labelres8 = Label(self.resultframe1, text = title_url[7][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres8 = Label(self.resultframe1, text = title_url[7][1], fg="blue", cursor="hand2", bg="white")
#gui2 loc
self.resultframe1.place(x=15,y=80)
self.searchEntry1.place(x=15,y=15)
self.searchButton.place(x=550,y=18)
self.labelss.place(x=15,y=60)
self.timeLabel.place(x=15,y=630)
self.labelres1.place(x=1,y=30)
self.linkres1.place(x=5,y=60)
self.labelres2.place(x=1,y=90)
self.linkres2.place(x=5,y=120)
self.labelres3.place(x=1,y=150)
self.linkres3.place(x=5,y=180)
self.labelres4.place(x=1,y=210)
self.linkres4.place(x=5,y=240)
self.labelres5.place(x=1,y=270)
self.linkres5.place(x=5,y=300)
self.labelres6.place(x=1,y=330)
self.linkres6.place(x=5,y=360)
self.labelres7.place(x=1,y=390)
self.linkres7.place(x=5,y=420)
self.labelres8.place(x=1,y=450)
self.linkres8.place(x=5,y=480)
self.clearButton1.place(x=800,y=18)
self.searchEntry1.insert(END,query)
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (xTime), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
def graphloc():
self.graphButton.place(x = 550, y=50)
self.posButton.place(x = 800, y=50)
#eventfunc
def callback1(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[0][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback2(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[1][1]))
self.resultframe1.destroy()
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback3(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[2][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback4(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[3][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback5(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[4][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback6(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[5][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback7(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[6][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback8(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[7][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def searchAction(event):
try:
global query
global mTime
mTime = StringVar(None)
query = StringVar(None)
search_ = Search()
query = self.searchEntry1.get()
if query not in (None, '', ' '):
start_time = time.time()
global title_url
title_url = [None]
raw = search_.fetch_url(query)
title_url = search_.process_url(raw)
self.masters.withdraw()
mTime = (time.time() - start_time)
self.guiresults()
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (mTime), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
else:
tkMessageBox.showinfo('Info', 'You must put a keyword')
except Exception as e:
tkMessageBox.showinfo('Info', 'No Internet Connection Try Again Later')
exit()
#eventlink
self.searchButton.bind("<Button-1>",searchAction)
self.searchEntry1.bind("<Return>",searchAction)
self.linkres1.bind("<Button-1>", callback1)
self.linkres2.bind("<Button-1>", callback2)
self.linkres3.bind("<Button-1>", callback3)
self.linkres4.bind("<Button-1>", callback4)
self.linkres5.bind("<Button-1>", callback5)
self.linkres6.bind("<Button-1>", callback6)
self.linkres7.bind("<Button-1>", callback7)
self.linkres8.bind("<Button-1>", callback8)
self.labelres1.bind("<Button-1>", callback1)
self.labelres2.bind("<Button-1>", callback2)
self.labelres3.bind("<Button-1>", callback3)
self.labelres4.bind("<Button-1>", callback4)
self.labelres5.bind("<Button-1>", callback5)
self.labelres6.bind("<Button-1>", callback6)
self.labelres7.bind("<Button-1>", callback7)
self.labelres8.bind("<Button-1>", callback8)
self.searchEntry1.insert(END,'')
class Kmers(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.customFont = Font(family="consolas", size=10)
self.seq = ""
self.kmer = 2
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title("Kmers")
self.pack(fill=BOTH, expand=False)
Label(self, text="Fichier de la Sequence:").grid(sticky=W + E + S + N,
row=0,
column=0,
padx=5,
pady=5)
Label(self, text="Nombre des Kmers:").grid(sticky=W + E + S + N,
row=1,
column=0,
padx=5,
pady=5)
self.btn = Button(self, text="Open File", command=self.onOpen)
self.btn.grid(sticky=E, row=0, column=0, padx=5, pady=5)
self.e1 = tkinter.Entry(self, state="disabled")
self.e1.configure(width=12)
self.e1.grid(sticky=E, row=1, column=0, padx=5, pady=5)
self.btn2 = Button(self,
text="Calcule",
state="disabled",
command=self.onCalcule)
self.btn2.grid(sticky=W + E + S + N, row=1, column=1, padx=5, pady=5)
lbl = Label(self, text="Infos")
#lbl.grid(sticky=W, row=2, column=0, padx=5)
self.v = tkinter.IntVar()
self.v = 2
r1 = tkinter.Radiobutton(self,
text="Euclidenne",
variable=self.v,
value=1)
r2 = tkinter.Radiobutton(self,
text="Correlation",
variable=self.v,
value=2)
r1.grid(sticky=W, row=2, column=0, padx=5)
r2.grid(sticky=W, row=2, column=1, padx=5)
lbl2 = Label(self, text="List Kmers")
lbl2.grid(sticky=W, row=0, column=2, padx=5)
self.area = ScrolledText(self, wrap=tkinter.WORD)
self.area.configure(state="disabled",
font=self.customFont,
height=20,
width=50)
self.area.grid(padx=5, pady=2, row=3, columnspan=2, rowspan=30)
self.listbox = tkinter.Listbox(self)
self.listbox.config(height=25, width=58)
self.listbox.grid(pady=5, row=1, column=2, rowspan=30)
lbl = Label(self, text="1. Proportion genome")
lbl.grid(sticky=W + E + S + N, row=0, column=4, padx=5)
lbl = Label(self, text="Pas:"******"Fenetre:")
lbl.grid(sticky=W + E + S + N, row=2, column=4, padx=5)
self.e2 = tkinter.Entry(self, state="disabled")
self.e2.configure(width=12)
self.e2.grid(sticky=E, row=1, column=4, padx=5, pady=5)
self.e3 = tkinter.Entry(self, state="disabled")
self.e3.configure(width=12)
self.e3.grid(sticky=E, row=2, column=4, padx=5, pady=5)
self.btn3 = Button(self,
text="Calcule",
state="disabled",
command=self.onCalcule2)
self.btn3.grid(sticky=W + E + S + N, row=2, column=5, padx=5, pady=5)
lbl = Label(self, text="Calcule subparties")
lbl.grid(sticky=W + E + S + N, row=3, column=4, padx=5)
lbl = Label(self, text="Pas:"******"Fenetre:")
lbl.grid(sticky=W + E + S + N, row=5, column=4, padx=5)
self.e4 = tkinter.Entry(self, state="disabled")
self.e4.configure(width=12)
self.e4.grid(sticky=E, row=4, column=4, padx=5, pady=5)
self.e5 = tkinter.Entry(self, state="disabled")
self.e5.configure(width=12)
self.e5.grid(sticky=E, row=5, column=4, padx=5, pady=5)
self.btn4 = Button(self,
text="Calcule",
state="disabled",
command=self.onCalcule3)
self.btn4.grid(sticky=W + E + S + N, row=5, column=5, padx=5, pady=5)
self.imp = tkinter.BooleanVar()
self.cb = tkinter.Checkbutton(self,
text="Imprimer Partie Genome diferente",
state="disabled",
variable=self.imp,
command=self.onClick)
self.cb.grid(sticky=W + E + S + N,
row=6,
column=4,
columnspan=2,
padx=5,
pady=5)
self.btn5 = Button(self,
text="Creer Phylo",
state="disabled",
command=self.onCalcule4)
self.btn5.grid(sticky=W + E + S + N,
row=7,
column=4,
columnspan=2,
padx=5,
pady=5)
self.btn6 = Button(self,
text="Creer Reseau Relations",
state="disabled",
command=self.onCalcule5)
self.btn6.grid(sticky=W + E + S + N,
row=8,
column=4,
columnspan=2,
padx=5,
pady=5)
lbl = Label(self, text="2. Choisir genome / genome Predicte")
lbl.grid(sticky=W + E + S + N, row=0, column=7, columnspan=2, padx=5)
lbl = Label(self, text="Taille morceau")
lbl.grid(sticky=W + E + S + N, row=1, column=7, padx=5)
self.e7 = tkinter.Entry(self, state="disabled")
self.e7.configure(width=12)
self.e7.grid(sticky=E, row=1, column=8, padx=5, pady=5)
self.btn7 = Button(self,
text="Cherching morceau",
state="disabled",
command=self.onCalcule6)
self.btn7.grid(sticky=W + E + S + N,
row=2,
column=7,
columnspan=2,
padx=5,
pady=5)
lbl = Label(self, text="3. Experience aleatoire un genome")
lbl.grid(sticky=W + E + S + N, row=4, column=7, columnspan=2, padx=5)
lbl = Label(self, text="Taille morceau")
lbl.grid(sticky=W + E + S + N, row=5, column=7, padx=5)
self.e8 = tkinter.Entry(self, state="disabled")
self.e8.configure(width=12)
self.e8.grid(sticky=E, row=5, column=8, padx=5, pady=5)
lbl = Label(self, text="Nombre de fois")
lbl.grid(sticky=W + E + S + N, row=6, column=7, padx=5)
self.e9 = tkinter.Entry(self, state="disabled")
self.e9.configure(width=12)
self.e9.grid(sticky=E, row=6, column=8, padx=5, pady=5)
self.btn8 = Button(self,
text="Lancer l'experience ",
state="disabled",
command=self.onCalcule7)
self.btn8.grid(sticky=W + E + S + N,
row=7,
column=7,
columnspan=2,
padx=5,
pady=5)
lbl = Label(self, text="3. Experience aleatoire tous les genomes")
lbl.grid(sticky=W + E + S + N, row=8, column=7, columnspan=2, padx=5)
lbl = Label(self, text="Taille morceau")
lbl.grid(sticky=W + E + S + N, row=9, column=7, padx=5)
self.e10 = tkinter.Entry(self, state="disabled")
self.e10.configure(width=12)
self.e10.grid(sticky=E, row=9, column=8, padx=5, pady=5)
lbl = Label(self, text="Nombre de fois")
lbl.grid(sticky=W + E + S + N, row=10, column=7, padx=5)
self.e11 = tkinter.Entry(self, state="disabled")
self.e11.configure(width=12)
self.e11.grid(sticky=E, row=10, column=8, padx=5, pady=5)
self.btn9 = Button(self,
text="Lancer l'experience ",
state="disabled",
command=self.onCalcule8)
self.btn9.grid(sticky=W + E + S + N,
row=11,
column=7,
columnspan=2,
padx=5,
pady=5)
def onOpen(self):
ftypes = [('Fna files', '*.fna')]
dlg = filedialog.Open(self, filetypes=ftypes)
fl = dlg.show()
n = len(fl.split('/')[-1]) + 1
path = fl[:-n]
start = timeit.default_timer()
onlyfiles = [f for f in listdir(path) if isfile(join(path, f))]
message = "Liste des genomes charges: \n"
self.sequences = {}
for f in onlyfiles:
s = path + '/' + f
name, genome = lireSeq(s)
self.sequences[name] = genome
message = message + name + '\n'
stop = timeit.default_timer()
time_total = stop - start
message += '\n'
message += ' --> Time reading : ' + str(time_total) + '\n\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
self.btn2.configure(state="normal")
self.e1.configure(state="normal")
def onCalcule(self):
k = self.e1.get()
try:
self.kmer = int(k)
self.e1.configure(state="disabled")
self.btn2.configure(state="disabled")
self.area.configure(state="normal")
message = "Kmer calcule : " + str(k) + "\n"
self.area.insert(END, message)
self.area.configure(state="disabled")
start = timeit.default_timer()
self.dico_k_mers = do_dic_kmers(self.kmer, alphabet_nt)
try:
self.dicProfils = do_profils_all_genomes(
self.sequences, self.dico_k_mers, self.kmer)
"""
cont = 0
for key in self.dicProfils.keys():
l = list(self.dicProfils[key].values()).count(0)
string = key+ " Lenght Profil: "+ str(len(self.dicProfils[key])-l)
self.listbox.insert(cont, string)
cont += 1
"""
except Exception as e:
print("ici INI", e)
stop = timeit.default_timer()
time_total = stop - start
message = ' --> Time calculating Profils : ' + str(
time_total) + '\n\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
self.btn3.configure(state="normal")
self.e2.configure(state="normal")
self.e3.configure(state="normal")
self.btn7.configure(state="normal")
self.e7.configure(state="normal")
self.btn8.configure(state="normal")
self.e8.configure(state="normal")
self.e9.configure(state="normal")
self.btn9.configure(state="normal")
self.e10.configure(state="normal")
self.e11.configure(state="normal")
except Exception as e:
print("ici INI2", e)
mbox.showwarning("Warning", "Number must be Integer")
def onCalcule2(self):
pas = self.e2.get()
fenetre = self.e3.get()
self.pas = []
self.fenetres = []
self.positions = {}
self.infoDistances = {}
self.partieGenomeDif = {}
self.cont = 0
try:
self.cont = 0
self.pas.append(int(pas))
self.fenetres.append(int(fenetre))
self.area.configure(state="normal")
message = "Proportion Genome : pas: "******" fenetre: " + str(fenetre) + " \n"
message += "Calcule distance..." + "\n"
self.area.insert(END, message)
self.area.configure(state="disabled")
start = timeit.default_timer()
self.parties = do_sub_parts(self.dicProfils, self.sequences,
int(pas), int(fenetre),
self.dico_k_mers, self.kmer, self.v)
pdfFile = path_dir + '/images/FirstParties.pdf'
pp = PdfPages(pdfFile)
means = do_mean_sub_parts(self.parties)
ecarts = do_sd_sub_parts(self.parties, means)
message = "Position dans le genome avec la max dist: \n"
try:
for i in self.parties.keys():
self.positions[i] = [
self.parties[i].index(max(self.parties[i])) *
(int(pas))
]
listI = []
listI.append(
[max(self.parties[i]), means[i] + ecarts[i] * 2])
self.infoDistances[i] = listI
message += i + ' pos: ' + str(
self.positions[i][self.cont]) + "\n"
message += '\n'
except Exception as e:
print("ici 2", e)
try:
self.plot_for_each_genome(self.parties, pp, self.pas,
self.positions, self.fenetres,
self.cont, True, means, ecarts)
except Exception as e:
print("ici 1", e)
subprocess.Popen([pdfFile], shell=True)
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
try:
self.partieGenomeDif = get_partieDif_all_genomes(
self.sequences, self.positions, self.pas, int(fenetre),
self.cont)
except Exception as e:
print("ici 3", e)
stop = timeit.default_timer()
time_total = stop - start
message = ' --> Time calculating sub-parties : ' + str(
time_total) + '\n\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
self.btn3.configure(state="disabled")
self.e2.configure(state="disabled")
self.e3.configure(state="disabled")
self.btn4.configure(state="normal")
self.e4.configure(state="normal")
self.e5.configure(state="normal")
except Exception as e:
print("ici 3", e)
mbox.showwarning("Warning", "Number must be Integer")
def myplotcode(self, x, y):
fig = plt.figure(figsize=(40, 40))
ax = fig.add_subplot(111)
x_points = range(0, len(x))
y_points = y
ax.plot(x_points, y_points, 'b')
ax.set_xlabel('Parties Genome')
ax.set_ylabel('Distance')
ax.set_title('Distribution proportion Genome')
return fig
def plot_for_each_genome(self, sub_parts_for_each_genome, pp, pas,
positions, fenetres, cont, boolean, means,
ecarts):
try:
for i in sub_parts_for_each_genome.keys():
fig = plt.figure()
ax = fig.add_subplot(111)
pos = 0
position = positions[i]
if boolean:
pos = int(position[cont] - (fenetres[cont] / 2))
else:
pos = int(position[-1] - (fenetres[-2] / 2))
if pos < 0:
pos = 0
if cont == 0:
xVector = range(
0,
len(sub_parts_for_each_genome[i]) * pas[cont],
pas[cont])
x_points = xVector
else:
xVector = range(
pos,
pos + len(sub_parts_for_each_genome[i]) * pas[cont],
pas[cont])
x_points = xVector
y_points = sub_parts_for_each_genome[i]
plt.plot(x_points, y_points, 'b')
ax.set_xlabel('Position')
ax.set_ylabel('Distance')
ax.set_title(i)
x = x_points
y = len(x) * [means[i]]
plt.plot(x, y)
x = x_points
y = len(x) * [means[i] + ecarts[i] * 2]
plt.plot(x, y)
x = x_points
y = len(x) * [means[i] - ecarts[i] * 2]
plt.plot(x, y)
pp.savefig()
pp.close()
except Exception as e:
print(e)
def onCalcule3(self):
pas = self.e4.get()
fenetre = self.e5.get()
self.cont += 1
try:
if int(fenetre
) == self.fenetres[-1] or int(fenetre) > self.fenetres[-1]:
mbox.showwarning(
"Warning",
"La fenetre foit etre de taille inferieure a la derniere fenetre"
)
return
else:
self.pas.append(int(pas))
self.fenetres.append(int(fenetre))
self.area.configure(state="normal")
message = "Proportion subpartie : pas: "******" fenetre: " + fenetre + " \n"
message += "Calcule distance..." + "\n"
self.area.insert(END, message)
self.area.configure(state="disabled")
start = timeit.default_timer()
self.parties = do_sub_parts(self.dicProfils, self.partieGenomeDif,
int(pas), int(fenetre),
self.dico_k_mers, self.kmer, self.v)
means = do_mean_sub_parts(self.parties)
ecarts = do_sd_sub_parts(self.parties, means)
pdfFile = path_dir + '/images/SubParties' + str(self.cont) + '.pdf'
pp = PdfPages(pdfFile)
try:
message = "Position dans le genome avec la max dist: \n"
for i in self.parties.keys():
list_i = self.positions[i]
pos = 0
pos = int((list_i[-1] - (self.fenetres[-2]) / 2) +
self.parties[i].index(max(self.parties[i])) *
int(pas))
if pos < 0:
pos = 0
list_i.append(pos)
self.positions[i] = list_i
listj = self.infoDistances[i]
listj.append(
[max(self.parties[i]), means[i] + ecarts[i] * 2])
self.infoDistances[i] = listj
message += i + ' pos: ' + str(pos) + '\n'
message += '\n'
except Exception as e:
print(e)
try:
self.plot_for_each_genome(self.parties, pp, self.pas,
self.positions, self.fenetres,
self.cont, False, means, ecarts)
except Exception as e:
print("ici 1", e)
subprocess.Popen([pdfFile], shell=True)
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
try:
self.partieGenomeDif = get_partieDif_all_genomes(
self.sequences, self.positions, self.pas, int(fenetre),
self.cont)
matrice, self.listCles = transfert_study(
self.dicProfils, self.partieGenomeDif, self.dico_k_mers,
self.kmer, self.v)
liste_probable_transfert = tranfert_study_result(
matrice, self.listCles, self.infoDistances)
self.relations = file_result(liste_probable_transfert,
"Resultats.txt")
self.types = []
for i in self.listCles:
self.types.append(i.split(":")[0])
except Exception as e:
print("ici 4", e)
stop = timeit.default_timer()
time_total = stop - start
message = ' --> Time calculating sub-parties : ' + str(
time_total) + '\n\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
self.cb.configure(state="normal")
self.btn5.configure(state="normal")
self.btn6.configure(state="normal")
except Exception as e:
print("ici 4", e)
mbox.showwarning("Warning", "Number must be Integer")
def onClick(self):
if self.imp.get() == True:
self.area.configure(state="normal")
self.area.insert(
END,
"Fichier creee et sauvegarde dans le repertoire actuel : Nom fichier : SeqDifs.txt \n\n"
)
self.area.configure(state="disabled")
sequencesDif(self.partieGenomeDif)
def onCalcule4(self):
pp = PdfPages(path_dir + '\\images\\Phylogenie.pdf')
matrice, liste = do_data_matrix(self.dicProfils)
Z = linkage(matrice, 'ward')
fig = plt.figure(figsize=(30, 10))
ax = fig.add_subplot(111)
ax.set_title('Hierarchical Clustering Dendrogram Genomes')
ax.set_xlabel('Distance')
ax.set_ylabel('Genomes')
dendrogram(Z,
leaf_rotation=0.,
leaf_font_size=6.,
orientation='right',
labels=liste)
fig.show()
pp.savefig()
pp.close()
self.fenetrePlot(fig, "Phylogenie")
def fenetrePlot(self, fig, title):
self.plot = tkinter.Toplevel(self)
self.plot.geometry("700x700+100+100")
self.plot.wm_title(title)
self.plot.canvas = FigureCanvasTkAgg(fig, master=self.plot)
self.plot.canvas.show()
self.plot.canvas.get_tk_widget().pack()
def onCalcule5(self):
reseau2(self.relations, self.listCles, self.types)
#self.fenetrePlot(graph, title)
try:
subprocess.Popen([path_dir + "\\Reseau.pdf"], shell=True)
except Exception as e:
print("ici 4", e)
def onCalcule6(self):
taille = self.e7.get()
try:
self.taille = int(taille)
key = random.choice(list(self.sequences.keys()))
genome = self.sequences[key]
rand = random.randint(0, len(genome) - self.taille)
randomSeq = genome[rand:rand + self.taille]
message = 'Genome Aleatoire : \n'
message += key + '\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
profilMorceau = do_profil_genome(randomSeq, self.dico_k_mers,
self.kmer)
ind = transfert_studyBoutGenome(self.dicProfils, profilMorceau,
self.v)
message = 'Genome predicte \n'
message += ind + '\n\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
except Exception as e:
print("ici 4", e)
mbox.showwarning("Warning", "Number must be Integer")
def onCalcule7(self):
taille = self.e8.get()
expFois = self.e9.get()
try:
self.taille = int(taille)
self.fois = int(expFois)
vectResultat, genome = experiment(self.dicProfils, self.sequences,
self.dico_k_mers, self.kmer,
self.fois, self.taille, self.v)
erreur = errorRate(vectResultat)
message = 'Genome Aleatoire\n'
message += genome + '\n'
message += "Taux d'erreur pour le genome choisi : " + str(
erreur) + '\n\n'
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
except Exception as e:
print("ici 4", e)
mbox.showwarning("Warning", "Number must be Integer")
def onCalcule8(self):
taille = self.e10.get()
expFois = self.e11.get()
try:
self.taille = int(taille)
self.fois = int(expFois)
erreur, genomes = experiment2(self.dicProfils, self.sequences,
self.dico_k_mers, self.kmer,
self.fois, self.taille, self.v)
types = []
for i in genomes:
types.append(i.split(":")[0])
fig = plt.figure(figsize=(25, 10))
width = 0.2
ax = fig.add_subplot(111)
ax.set_title("Taux d'erreur predictions")
ax.set_xlabel('Genomes')
ax.set_ylabel("Taux d'erreur")
ind = np.arange(len(genomes))
plt.bar(ind, erreur, width, color='b')
plt.xticks(ind + width / 2., types, rotation=45)
plt.yticks(np.arange(0, 1.5, 0.2))
fig.show()
self.fenetrePlot(fig, "Taux d'erreur")
message = 'Genome aleatoire\n'
message += 'Calcule pour tous les genomes\n'
message += 'Prediction des ' + str(
self.fois) + " bouts aleatoires pour chaque genome \n\n"
self.area.configure(state="normal")
self.area.insert(END, message)
self.area.configure(state="disabled")
except Exception as e:
print("ici 4", e)
mbox.showwarning("Warning", "Number must be Integer")
backBtn = tk.Button(window, text="Back Annotate", command=BackAnn)
backBtn.grid(row=1, column=1, sticky="wens", padx=5, pady=5)
progress = ttk.Progressbar(window,
orient="horizontal",
length=100,
mode="determinate")
progress.grid(row=3, column=1, sticky="wens", padx=5)
if sys.version_info.major < 3:
from ScrolledText import ScrolledText
else:
from tkinter.scrolledtext import ScrolledText
st = ScrolledText(window, state='disabled', width=60, height=10)
st.configure(font='TkFixedFont')
# Make the scroll window resizing...
tk.Grid.rowconfigure(window, 4, weight=1)
tk.Grid.columnconfigure(window, 0, weight=1)
st.grid(row=4, column=0, columnspan=2, sticky="nswe", pady=5, padx=5)
# Create textLogger
text_handler = TextHandler(st)
# Add the handler to logger
logger = logging.getLogger()
logger.addHandler(text_handler)
#set level to print out all. Otherwise this will ignore the debug an info prints.
logger.root.setLevel(logging.NOTSET)
st.update()
def __init__(self, parent):
global online
global callsign
global callsign_temp
global command_desc
global command_raw
global last_command
global logger
global parsed_data
global tx_power
global serial_port
global serial_port_options
global port_list
global callsign_entry
global command_listbox
global connect_button
global data_textbox
global qrcode_label
# Create main Frame
tk.Frame.__init__(self, parent)
self.parent = parent
self.parent.title("Argo 2 Ground Station")
# Add UI components
# Menu Bar
self.menu_bar = tk.Menu(self)
self.parent.config(menu=self.menu_bar)
# File Menu
self.file_menu = tk.Menu(self.menu_bar)
self.file_menu.add_command(label="Exit", underline=0, command=on_exit)
# Receiver Menu
self.capsule_menu = tk.Menu(self.menu_bar)
self.capsule_menu.add_command(label="Capsule Status",
underline=0,
command=show_status_window)
self.capsule_menu.add_separator()
self.capsule_menu.add_command(label="Send Command",
underline=0,
command=send_command)
# HabHub Menu
self.tracking_menu = tk.Menu(self.menu_bar)
self.tracking_menu.add_command(
label="Google Maps",
underline=0,
command=lambda: webbrowser.open("http://google.com/maps/place/" +
parsed_data[3][1].get(
) + "," + parsed_data[4][1].get()))
self.tracking_menu.add_command(
label="HabHub",
underline=0,
command=lambda: webbrowser.open("http://tracker.habhub.org/"))
self.tracking_menu.add_separator()
self.tracking_menu.add_checkbutton(label="Online",
underline=0,
offvalue=0,
onvalue=1,
variable=online)
# Help Menu
self.help_menu = tk.Menu(self.menu_bar)
self.help_menu.add_command(label="Help",
underline=0,
command=self.show_help)
self.help_menu.add_command(label="About",
underline=0,
command=self.show_about)
# Add Menus to Menu Bar
self.menu_bar.add_cascade(label="File",
underline=0,
menu=self.file_menu)
self.menu_bar.add_cascade(label="Capsule",
underline=0,
menu=self.capsule_menu)
self.menu_bar.add_cascade(label="Tracking",
underline=2,
menu=self.tracking_menu)
self.menu_bar.add_cascade(label="Help",
underline=0,
menu=self.help_menu)
# Frames
left_frame = tk.Frame(self.master)
# Serial Port Label
tk.Label(left_frame, text="Port:").grid(row=0, column=0)
# Serial Port OptionMenu - allow user to choose serial port to connect to
serial_port = tk.StringVar(self.master)
port_list = ("", "")
serial_port_options = tk.OptionMenu(left_frame, serial_port,
*list(port_list))
serial_port_options.config(width=6)
serial_port_options.bind('<Button-1>', update_serial_list)
serial_port_options.grid(row=0, column=1, sticky='w', padx=(10, 0))
# Serial Port Connect Button
connect_button = tk.Button(left_frame,
text="Connect",
command=connect_serial)
connect_button.grid(row=1,
column=1,
columnspan=2,
sticky='w',
padx=12,
pady=(0, 30))
# Callsign Label
tk.Label(left_frame, text="Callsign:").grid(row=2,
column=0,
sticky='e')
# Callsign Entry
callsign_temp = tk.StringVar(self.master)
callsign_temp.set("PAN1")
callsign_entry = tk.Entry(left_frame,
width=12,
textvariable=callsign_temp)
callsign_entry.grid(row=2, column=1)
# Callsign Set Button
callsign = tk.StringVar(self.master)
callsign.set("PAN1")
callsign_button = tk.Button(left_frame,
text="Set callsign",
command=set_callsign)
callsign_button.grid(row=3,
column=1,
columnspan=2,
sticky='w',
padx=(7, 0))
# Online Checkbox - allows user to decide whether to send data to HabHub or not
self.online_checkbutton = tk.Checkbutton(left_frame,
text="Offline",
fg="red",
variable=online)
self.online_checkbutton.grid(row=4,
column=1,
columnspan=2,
sticky='w',
padx=(5, 0),
pady=(20, 0))
# Data Text Box - data recieved from capsule
data_textbox = ScrolledText(self.master, relief='sunken')
data_textbox.configure(state=tk.DISABLED,
width=64,
height=16,
wrap=tk.NONE) # Make data uneditable
data_textbox.grid(row=0,
column=2,
columnspan=5,
padx=(20, 0),
pady=(10, 10))
#data_scrollbar = tk.Scrollbar(self.master, command=data_textbox.yview)
#data_scrollbar.grid()
left_frame.columnconfigure(0, pad=10)
left_frame.rowconfigure(0, pad=10)
left_frame.rowconfigure(1, pad=10)
left_frame.rowconfigure(2, pad=10)
left_frame.rowconfigure(3, pad=10)
left_frame.grid(row=0, column=0)
# Command Listbox
command_listbox = tk.Listbox(self.master)
for cmd_num in xrange(0, len(GENERAL_COMMANDS)):
command_listbox.insert(cmd_num, GENERAL_COMMANDS[cmd_num][0])
command_listbox.bind('<<ListboxSelect>>', on_select_command)
command_listbox.grid(row=1, column=0, rowspan=4, sticky='n')
# Command Entry
command_raw = tk.StringVar()
command_entry = tk.Entry(self.master,
width=20,
textvariable=command_raw)
command_entry.grid(row=1,
column=2,
padx=(20, 0),
pady=(3, 0),
sticky='nw')
# Command Description
command_desc = tk.StringVar()
command_desc_label = tk.Label(self.master,
textvariable=command_desc,
justify=tk.LEFT)
command_desc_label.grid(row=2,
column=2,
columnspan=4,
rowspan=2,
padx=(20, 0),
sticky='nw')
# Command TX Power
tk.Label(self.master, text="TX Power:").grid(row=1,
column=4,
sticky='ne',
pady=(3, 0))
tx_power = tk.StringVar()
tx_power.set(20)
command_power_option = ttk.Combobox(self.master,
width=5,
state='readonly',
textvariable=tx_power)
command_power_option['values'] = list(reversed(range(5, 23 + 1)))
command_power_option.grid(row=1, column=5, sticky='ne', pady=(3, 0))
# Command Buttons (Send Command and Last Command)
last_command = ""
last_command_button = tk.Button(
self.master,
text="Load Last Command",
command=lambda: command_raw.set(last_command))
last_command_button.grid(row=1, column=3, sticky='nw')
send_command_button = tk.Button(self.master,
text="Send Command",
command=send_command)
send_command_button.grid(row=1, column=6, sticky='ne')
# Status Button (show Status Window)
status_button = tk.Button(self.master,
text="Show Status Window",
command=show_status_window)
status_button.grid(row=4, column=6, sticky='se')
# QR Code Label
tk.Label(self.master, text="Google Maps:").grid(row=2,
column=6,
sticky='se',
pady=(0, 0))
qrcode = pyqrcode.create('No data yet...')
# Create XBM image
qr_xbm = qrcode.xbm(scale=2)
# Create Tkinter Bitmap
qr_bmp = tk.BitmapImage(data=qr_xbm)
# Create label with image
qrcode_label = tk.Label(self.master, image=qr_bmp)
# Save reference to change image later
qrcode_label.image = qr_bmp
qrcode_label.grid(row=3, column=6, sticky='e')
# Setup serial check in 100 ms (to repeat forever)
self.after(100, get_serial_data)
class LogReader(object):
def __init__(self, root, **kwargs):
self.root = root
self.filenameLog = kwargs.get('filenameLog', None)
self.ClearDisplay = kwargs.get('ClearDisplay', False)
''' By default don't display Filenames and directory '''
mainstyle = ttk.Style()
# mainstyle.theme_use(mainstyle.theme_names()[0])
mainstyle.configure('My.TFrame',
background='gray50',
foreground='gray97',
font="Monospace 12")
Btnstyle = ttk.Style()
Btnstyle.configure('My.TButton',
background='gray50',
foreground='gray97',
font="Monospace 12")
root.title("Log reader v0.1")
Chkstyle = ttk.Style()
Chkstyle.configure('My.TCheckbutton',
background='gray50',
foreground='gray97',
font="Monospace 12")
Chkstyle = ttk.Style()
Chkstyle.configure('My.TLabel',
background='gray50',
foreground='gray97',
font="Monospace 12")
root.title("Libretto v0.1")
self.initParam()
#======================================================================
# Main Frame
#======================================================================
self.f0 = ttk.Frame(self.root, style='My.TFrame')
self.f0.pack(expand=True, fill='both')
LabelUP = ttk.Label(
self.f0, text="Please select the log file then click on read",
style='My.TLabel')
LabelUP.pack(side="top")
self.fDisp = ttk.Frame(self.f0, style='My.TFrame')
self.fDisp.pack(expand=True, fill='both', side="right")
self.fParam = ttk.Frame(self.f0, style='My.TFrame')
self.fParam.pack(side="left")
#======================================================================
# Frame fDisp
#======================================================================
# Display stdout
self.customFont = tkFont.Font(
family="Helvetica", size=12)
self.text_area = ScrolledText(
self.fDisp, font=self.customFont, undo=True, background='gray20', foreground="gray92")
self.text_area.pack(expand=True, fill='both')
self.text_area.configure(state='normal')
self.text_area.yview(END)
self.text_area.after(0)
self.text_area.tag_configure("comment",
font="Helvetica 12",
foreground="gray60")
self.text_area.tag_configure("subsubTitle",
font="Helvetica 12 bold")
self.text_area.tag_configure("subTitle",
font="Helvetica 14 bold")
self.text_area.tag_configure("Title",
font="Helvetica 16 bold")
self.text_area.tag_configure("warn",
font="Helvetica 12 bold",
foreground="red")
self.text_area.tag_configure("File",
font="Helvetica 10",
foreground="DarkSlateGray1")
self.text_area.tag_configure("FileOther",
font="Helvetica 10",
foreground="plum")
self.text_area.tag_configure("Directory",
font="Helvetica 10",
foreground="goldenrod1")
self.text_area.tag_configure("validate",
font="Helvetica 12 bold",
foreground="OliveDrab1")
self.text_area.tag_configure("param",
font="Helvetica 12",
foreground="wheat")
# stdout redirection
sys.stdout = StdoutRedirector(self.text_area)
#======================================================================
# Parameters
#======================================================================
# File Selection button
SelectLogFileBtn = ttk.Button(
self.fParam, text="Select the log file", style='My.TButton')
SelectLogFileBtn.grid(row=0, column=0)
SelectLogFileBtn.configure(command=lambda: self.set_LogFile())
Label = ttk.Label(self.fParam, text="", style='My.TLabel')
Label.grid(row=1, column=0)
# Refresh button
SelectLogFileBtn = ttk.Button(
self.fParam, text="Refresh", style='My.TButton')
SelectLogFileBtn.grid(row=2, column=0)
SelectLogFileBtn.configure(command=lambda: self.RefreshLog())
Label = ttk.Label(self.fParam, text="", style='My.TLabel')
Label.grid(row=9, column=0)
# Display Files button
ChkBtnDispFilenames = ttk.Checkbutton(
self.fParam, text="Display the filenames", style='My.TCheckbutton')
ChkBtnDispFilenames.grid(row=10, column=0)
ChkBtnDispFilenames.configure(variable=self.Entry_DispFilenames,
command=lambda: self.set_DispFilenames())
# Display Comments button
ChkBtnDispCom = ttk.Checkbutton(
self.fParam, text="Display the comments", style='My.TCheckbutton')
ChkBtnDispCom.grid(row=11, column=0)
ChkBtnDispCom.configure(variable=self.Entry_DispComment,
command=lambda: self.set_DispComment())
# Display Directories button
ChkBtnDispDir = ttk.Checkbutton(
self.fParam, text="Display the directories", style='My.TCheckbutton')
ChkBtnDispDir.grid(row=12, column=0)
ChkBtnDispDir.configure(variable=self.Entry_DispDir,
command=lambda: self.set_DispDir())
# Display Warnings button
ChkBtnDispWarn = ttk.Checkbutton(
self.fParam, text="Display the warnings", style='My.TCheckbutton')
ChkBtnDispWarn.grid(row=13, column=0)
ChkBtnDispWarn.configure(variable=self.Entry_DispWarn,
command=lambda: self.set_DispWarn())
# Display Warnings button
ChkBtnDispParam = ttk.Checkbutton(
self.fParam, text="Display the parameters", style='My.TCheckbutton')
ChkBtnDispParam.grid(row=14, column=0)
ChkBtnDispParam.configure(variable=self.Entry_DispParam,
command=lambda: self.set_DispParam())
self.RefreshLog()
if self.ClearDisplay:
self.UpdateAllDisp()
def printExample(self):
return ["=========================================",
"= Welcome in the Log Reader ",
"=========================================",
"", "=== This is a big title ! ===",
" ~ A little bit different of this sub-Title",
" * And guess what, now a sub-sub-Title ! ",
" # right now I am commenting my example",
" p_Dodo is a parameter",
" BlablablaAudyIsTheBestBlablabla...",
" X_something is a most of the time the filename of " +
" an MRI image or created",
" Z_something is the filename of a file which is not an " +
"mri image (it can be some stats or a matrix)",
" D_anotherthing is a directory",
" > Well this task seems to be a success",
" !! But this is a message you should read"]
def initParam(self):
self.logExtension = ("*.txt", "*.log")
self.LogMessage = None
self.listHideBal = []
global DefaultFileNameMRIImage
global DefaultFileNameMRIMasks
global DefaultFileNameOther
global DefaultFileNameMatrix
global DefaultDirectory
global DefaultName
global DefaultWarning
global DefaultTitle
global DefaultSubTitle
global DefaultSubSubTitle
global DefaultComment
global DefaultValidate
global DefaultParameter
self.DefaultFileNameMRIImage = DefaultFileNameMRIImage
self.DefaultFileNameMRIMasks = DefaultFileNameMRIMasks
self.DefaultFileNameOther = DefaultFileNameOther
self.DefaultFileNameMatrix = DefaultFileNameMatrix
self.DefaultDirectory = DefaultDirectory
self.DefaultName = DefaultName
self.DefaultWarning = DefaultWarning
self.DefaultTitle = DefaultTitle
self.DefaultSubTitle = DefaultSubTitle
self.DefaultSubSubTitle = DefaultSubSubTitle
self.DefaultComment = DefaultComment
self.DefaultValidate = DefaultValidate
self.DefaultParameter = DefaultParameter
self.DispWarn = True
self.Entry_DispWarn = IntVar(value=1)
self.DispParam = True
self.Entry_DispParam = IntVar(value=1)
if self.ClearDisplay:
self.DispFilenames = False
self.Entry_DispFilenames = IntVar(value=0)
self.DispComment = False
self.Entry_DispComment = IntVar(value=0)
self.DispDir = False
self.Entry_DispDir = IntVar(value=0)
else:
self.DispFilenames = True
self.Entry_DispFilenames = IntVar(value=1)
self.DispComment = True
self.Entry_DispComment = IntVar(value=1)
self.DispDir = True
self.Entry_DispDir = IntVar(value=1)
def DispOrHide(self, DispSomething, listHideBal):
if DispSomething:
# update the balise to hide list
listHideBal = [e for e in self.listHideBal if e not in listHideBal]
else:
listHideBal = listHideBal + self.listHideBal
self.listHideBal = listHideBal
self.resetDisp()
self.watchLog(bal=self.listHideBal)
def set_DispFilenames(self):
self.DispFilenames = self.Entry_DispFilenames.get()
listbal0 = [self.DefaultFileNameMRIImage,
self.DefaultFileNameMatrix,
self.DefaultFileNameMRIMasks,
self.DefaultFileNameOther]
self.DispOrHide(self.DispFilenames, listbal0)
def set_DispDir(self):
self.DispDir = self.Entry_DispDir.get()
listbal0 = [self.DefaultDirectory]
self.DispOrHide(self.DispDir, listbal0)
def set_DispComment(self):
self.DispComment = self.Entry_DispComment.get()
listbal0 = [self.DefaultComment]
self.DispOrHide(self.DispComment, listbal0)
def set_DispWarn(self):
self.DispWarn = self.Entry_DispWarn.get()
listbal0 = [self.DefaultWarning]
self.DispOrHide(self.DispWarn, listbal0)
def set_DispParam(self):
self.DispParam = self.Entry_DispParam.get()
listbal0 = [self.DefaultParameter]
self.DispOrHide(self.DispParam, listbal0)
def UpdateAllDisp(self):
self.set_DispComment()
self.set_DispDir()
self.set_DispFilenames()
def set_LogFile(self):
self.filenameLog = self.OpenFile(
self.OriginalDirectory, self.logExtension)
self.RefreshLog()
def filterLog(self, str0, bal):
''' delete the lines which contain a specific balise '''
if type(bal) != list:
if type(bal) != str:
if not bal:
return str0
else:
bal = [bal]
try:
str1 = DeleteTabulation(str0)
except:
str1 = str0
for e in bal:
if str1[0:len(e)] == e:
return None
return str0
def loadLog(self):
''' load a log '''
if self.filenameLog:
with open(self.filenameLog) as f:
self.LogMessage = f.read().splitlines()
else:
self.LogMessage = self.printExample()
def watchLog(self, bal=None):
''' display the log '''
for line in self.LogMessage:
l = self.filterLog(line, bal)
if l:
print l
def resetDisp(self):
''' '''
self.text_area.delete('1.0', END)
def RefreshLog(self):
self.loadLog()
self.resetDisp()
self.watchLog(bal=self.listHideBal)
def OpenFile(self, initialdir0="", filetype='*.*'):
if filetype != '*.*':
filetypes0 = (("Files", filetype),
("All Files", "*.*"))
name = askopenfilename(initialdir=initialdir0,
filetypes=filetypes0,
title="Choose a file.")
else:
name = askopenfilename(initialdir=initialdir0,
title="Choose a file.")
return name
def close(self):
print "close"
exit()
loc=(0, 0))
# ======== User Control Logging Frame ========
frm_log = Frame(mw,
width=480,
height=330,
highlightbackground='gray',
highlightcolor='black',
highlightthickness=2)
frm_log.place(x=40, y=430, width=480, height=330)
log_text_area = ScrolledText(
master=frm_log,
# wrap=mw.WORD,
highlightthickness=0)
log_text_area.configure(state='disabled')
log_text_area.pack(fill=BOTH)
log_text_area.bind('<Command-a>', select_all_text)
# log_text_area.bind('<Control-a>', select_all_text)
# ======== Odometry and Measurement Logging Frame ========
frm_pos = Frame(mw,
width=511,
height=330,
highlightbackground='gray',
highlightcolor='black',
highlightthickness=2)
frm_pos.place(x=603, y=430, width=511, height=330)
pos_text_area = ScrolledText(
class Solo_Client:
def __init__(self, top=None):
'''This class configures and populates the toplevel window.
top is the toplevel containing window.'''
_bgcolor = '#d9d9d9' # X11 color: 'gray85'
_fgcolor = '#000000' # X11 color: 'black'
_compcolor = '#d9d9d9' # X11 color: 'gray85'
_ana1color = '#d9d9d9' # X11 color: 'gray85'
_ana2color = '#d9d9d9' # X11 color: 'gray85'
top.iconbitmap(r'icon.ico')
top.geometry("346x463+655+389")
top.title("Solo Client")
top.configure(background="#d9d9d9")
top.configure(highlightbackground="#d9d9d9")
top.configure(highlightcolor="black")
top.resizable(True, True)
top.bind('<Return>', asend)
self.menubar = Menu(top,font="TkMenuFont",bg=_bgcolor,fg=_fgcolor)
top.configure(menu = self.menubar)
self.Entry1 = Entry(top)
self.Entry1.place(relx=0.03, rely=0.91, relheight=0.06, relwidth=0.71)
self.Entry1.configure(background="white")
self.Entry1.configure(disabledforeground="#a3a3a3")
self.Entry1.configure(font="TkFixedFont")
self.Entry1.configure(foreground="#000000")
self.Entry1.configure(highlightbackground="#d9d9d9")
self.Entry1.configure(highlightcolor="black")
self.Entry1.configure(insertbackground="black")
self.Entry1.configure(selectbackground="#c4c4c4")
self.Entry1.configure(selectforeground="black")
self.Button1 = Button(top)
self.Button1.place(relx=0.78, rely=0.91, height=34, width=67)
self.Button1.configure(activebackground="#d9d9d9")
self.Button1.configure(activeforeground="#000000")
self.Button1.configure(background="#d9d9d9")
self.Button1.configure(disabledforeground="#a3a3a3")
self.Button1.configure(foreground="#000000")
self.Button1.configure(highlightbackground="#d9d9d9")
self.Button1.configure(highlightcolor="black")
self.Button1.configure(pady="0")
self.Button1.configure(text='''Send''')
self.Button1.configure(command = asend)
self.Text1 = ScrolledText(top)
self.Text1.place(relx=0.03, rely=0.02, relheight=0.87, relwidth=0.93)
self.Text1.configure(background="white")
self.Text1.configure(font="TkTextFont")
self.Text1.configure(foreground="black")
self.Text1.configure(highlightbackground="#d9d9d9")
self.Text1.configure(highlightcolor="black")
self.Text1.configure(insertbackground="black")
self.Text1.configure(insertborderwidth="3")
self.Text1.configure(selectbackground="#c4c4c4")
self.Text1.configure(selectforeground="black")
self.Text1.configure(undo="1")
self.Text1.configure(width=10)
self.Text1.configure(wrap=NONE)
class TextBox:
def __init__(self):
self.WIDTH = 600
self.HEIGHT = 800
self.FONT = "helvetica"
self.FONT_SIZE = 12
# colours specified as RGB fractions
self.bg_input = [1, 1, 1]
self.fg_input = [0, 0, 0]
self.bg_article = [0, 0, 0]
self.fg_min_article = [0.5, 0.5, 0.5]
self.fg_max_article = [0.9, 0.9, 0.9]
self.fg_solution_article = [1, 1, 1] #[0.3, 0.5, 1.0] #[1, 0.7, 0.4]
invert = False
if invert:
self.bg_input = [1. - v for v in self.bg_input]
self.fg_input = [1. - v for v in self.fg_input]
self.bg_article = [1. - v for v in self.bg_article]
self.fg_min_article = [1. - v for v in self.fg_min_article]
self.fg_max_article = [1. - v for v in self.fg_max_article]
self.text = "" # what is shown in the box
self.allText = "" # the text for the entire article
self.sentences = [] # list of sentences in article
# dictionary mapping from size to k-hot encoding indicating
# which sentences are in the summary
self.solutions = []
# (not used) how much weight is put on each sentence
self.weights = []
self.only_summary = True
self.summary_size = 1
self.summary_coherence = 0.0
self.summary_independence = 0.8
self.summarizer = Summarizer(parent=self)
self.root = Tk()
self.draw(init=True)
#self.root.mainloop()
def draw(self, init=False):
if init:
# show main article body
self.tk_article = ScrolledText(self.root)
# let user paste and enter text
self.tk_user_input = ScrolledText(self.root)
self.tk_summary_size_scale = Scale(self.root)
self.tk_summary_size_scale_label = Label(self.root, text="Length")
self.tk_summary_coherence_scale = Scale(self.root)
self.tk_summary_coherence_scale_label = Label(self.root,
text="Coherence")
self.tk_summary_independence_scale = Scale(self.root)
self.tk_summary_independence_scale_label = Label(
self.root, text="Independence")
self.tk_toggle_view = Button(self.root,
text="more",
command=self.handleToggleView)
self.tk_recalculate = Button(self.root,
text="Update",
command=self.handleRecalculate)
self.root.geometry("%dx%d" % (self.WIDTH, self.HEIGHT))
self.root.title("QuickReader V4")
self.tk_article.configure(width=25,
height=6,
bd=0,
highlightthickness=0,
wrap="word",
font=self.FONT)
self.tk_user_input.configure(width=25,
height=3,
bd=0,
highlightthickness=0,
wrap="word",
font=self.FONT)
self.tk_summary_size_scale.configure(
bd=0,
from_=0,
to=20,
orient=HORIZONTAL,
sliderrelief=FLAT,
command=lambda event: self.handleSlider(
self.tk_summary_size_scale.get()))
######
self.tk_summary_coherence_scale.configure(
bd=0,
from_=0,
to=1,
orient=HORIZONTAL,
sliderrelief=FLAT,
resolution=0.05,
command=lambda event: self.handleCoherenceSlider(
self.tk_summary_coherence_scale.get()))
self.tk_summary_coherence_scale.set(self.summary_coherence)
######
self.tk_summary_independence_scale.configure(
bd=0,
from_=0,
to=1.5,
orient=HORIZONTAL,
sliderrelief=FLAT,
resolution=0.05,
command=lambda event: self.handleIndependenceSlider(
self.tk_summary_independence_scale.get()))
self.tk_summary_independence_scale.set(self.summary_independence)
# set colours
self.root.configure(background="black")
self.tk_summary_size_scale.configure(troughcolor="#444444",
fg="black",
background="white",
activebackground="#bbbbbb")
self.tk_summary_coherence_scale.configure(
troughcolor="#444444",
fg="black",
background="white",
activebackground="#bbbbbb")
self.tk_summary_independence_scale.configure(
troughcolor="#444444",
fg="black",
background="white",
activebackground="#bbbbbb")
self.tk_article.configure(bg=toHex(self.bg_article),
fg="white",
insertbackground="blue")
self.tk_article.vbar.configure(bg="white",
width=10,
troughcolor="black")
self.tk_user_input.configure(bg=toHex(self.bg_input),
fg=toHex(self.fg_input),
insertbackground="blue")
self.tk_user_input.vbar.configure(bg="white",
width=10,
troughcolor="black")
self.tk_user_input.focus()
self.tk_user_input.bind("<KeyRelease-Return>",
(lambda event: self.handleUserInput(
self.tk_user_input.get("0.0", END))))
self.root.bind("<Configure>", self.resize)
def setText(self, text, redraw=False):
self.text = text
if redraw: self.updateArticleInfo()
def setSentences(self, sentences, redraw=False):
self.sentences = sentences
if redraw: self.updateArticleInfo()
def setSolutions(self, solutions, redraw=False):
self.solutions = solutions
if redraw: self.updateArticleInfo()
def setWeights(self, weights, redraw=False):
self.weights = weights
if redraw: self.updateArticleInfo()
def handleToggleView(self):
print("View toggle!")
self.only_summary = not self.only_summary
if self.only_summary:
self.tk_toggle_view.configure(text="more")
else:
self.tk_toggle_view.configure(text="less")
self.updateSummary()
def handleRecalculate(self):
print("Update!")
self.handleUserInput(self.allText)
def handleSlider(self, value):
print("Slider:", value)
self.summary_size = value
self.updateSummary()
def handleCoherenceSlider(self, value):
print("Coherence Slider:", value)
self.summary_coherence = value
#self.updateSummary()
def handleIndependenceSlider(self, value):
print("Independence Slider:", value)
self.summary_independence = value
#self.updateSummary()
def updateSummary(self):
l = self.summary_size
if self.only_summary and l != 0:
self.setText('\n\n'.join([
self.sentences[i] for i in range(len(self.sentences))
if self.solutions[l][i] == 1
]))
else:
self.setText(self.allText, redraw=False)
self.updateArticleInfo()
self.setWeights([0. for _ in self.sentences], redraw=True)
self.tk_article.yview_moveto(0) #vbar.set(0, 0) #configure(jump=0)
def handleUserInput(self, inStr):
self.tk_user_input.delete("0.0", END)
if inStr.strip() == "": return
text = inStr
text = ''.join([ch for ch in text if ord(ch) < 128])
self.setText(text, redraw=False)
self.setSolutions([], redraw=False)
self.setWeights([], redraw=True)
text, sentences, solutions = self.summarizer.summarize(
text,
coherence_weight=self.summary_coherence,
independence_weight=self.summary_independence,
size_weight=1.,
beam_width=3,
hard_size_limit=None)
self.allText = text
self.sentences = sentences
self.solutions = solutions
self.solutions[0] = [1. for _ in sentences]
# get max length for summary
max_len = max(solutions.keys())
set_len = min(max_len, 3)
self.tk_summary_size_scale.configure(from_=0, to=max_len)
self.tk_summary_size_scale.set(set_len)
self.summary_size = set_len
# text: all the text in one long string
# sentences: the text split up into a list of sentences
# solution: dictionary mapping summary size to a one-hot vector over the sentences, indicating
# which sentences are included in the summarization
# the text should be the same, but update it anyways since it needs to contain the
# exact same stuff as the sentences
self.updateSummary()
#self.updateArticleInfo()
def resize(self, event=[]):
LINEH = 20.0
pixelX = self.root.winfo_width()
pixelY = self.root.winfo_height()
bf = 5 # buffer size in pixels
# update find_icon, wiki_icon, and graph_icon
# set toggle and recalculate button
toggleW = 50
toggleH = 35 * 1
self.tk_toggle_view.place(x=pixelX - toggleW,
y=0,
width=toggleW,
height=toggleH)
updateW = 50
updateH = 35 * 2
self.tk_recalculate.place(x=pixelX - updateW,
y=toggleH,
width=updateW,
height=updateH)
buttonH = toggleH + updateH
labelW = 90
# set position of size scale
scaleW = pixelX - updateW - labelW
scaleH = 35
self.tk_summary_size_scale.place(x=labelW,
y=0,
width=scaleW,
height=scaleH)
self.tk_summary_size_scale_label.place(x=0,
y=0,
width=labelW,
height=scaleH)
# set position of coherence scale
coherenceW = pixelX - updateW - labelW
coherenceH = 35
self.tk_summary_coherence_scale.place(x=labelW,
y=scaleH,
width=scaleW,
height=scaleH)
self.tk_summary_coherence_scale_label.place(x=0,
y=scaleH,
width=labelW,
height=coherenceH)
# set position of independence scale
independenceW = pixelX - updateW - labelW
independenceH = 35
self.tk_summary_independence_scale.place(x=labelW,
y=scaleH + coherenceH,
width=scaleW,
height=scaleH)
self.tk_summary_independence_scale_label.place(x=0,
y=scaleH + coherenceH,
width=labelW,
height=independenceH)
# update user input
inputW = pixelX
inputH = int(3.0 * LINEH)
self.tk_user_input.place(x=0,
y=pixelY - inputH,
width=inputW,
height=inputH)
# update article
articleW = pixelX
articleH = pixelY - inputH - scaleH - coherenceH - independenceH
self.tk_article.place(x=0,
y=scaleH + coherenceH + independenceH,
width=articleW,
height=articleH)
def updateArticleInfo(self):
self.articleClear()
self.articleCat(self.text)
if self.weights != []:
self.articleColour()
self.root.update()
def articleClear(self):
self.tk_article.delete("1.0", END)
self.tk_article.update()
self.root.update()
return
def articleCat(self, inStr):
self.tk_article.insert(END, inStr)
self.tk_article.yview(END)
def articleColour(self):
'''
solution = self.solutions[self.summary_size]
allText = self.text #self.tk_article.get('1.0', 'end-1c')
# make sure weights are normalised
maxW = max(self.weights)
minW = min(self.weights)
weights = self.weights
if maxW != minW:
weights = [(v-minW)/(maxW-minW) for v in self.weights]
for i in range(len(self.sentences)):
if self.only_summary and solution[i] != 1.: continue
s = self.sentences[i]
if len(s.strip()) == 0:
continue
tagNameA = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for _ in range(10)])
L_Size = 12 # if solution[i] == 1 else 10
L_Colour = blend(self.fg_min_article, self.fg_max_article, weights[i])
L_Colour = self.fg_solution_article if solution[i] == 1 else L_Colour
countVar = StringVar(self.root)
pos = self.tk_article.search(s, "1.0", stopindex="end", count=countVar)
self.tk_article.tag_add(tagNameA, pos, "{} + {}c".format(pos, countVar.get()))
bolding = "normal" #"bold" if self.solution[i] == 1 else "normal" #
font = (self.FONT, L_Size, bolding)
self.tk_article.tag_config(tagNameA, foreground=toHex(L_Colour), font=font)#self.FONT+' %s'%(L_Size))
self.root.update()
'''
solution = self.solutions[self.summary_size]
allText = self.text #self.tk_article.get('1.0', 'end-1c')
#print("=========")
for i in range(len(self.sentences)):
if self.only_summary and solution[i] != 1.: continue
s = self.sentences[i]
#if len(s.strip()) == 0:
# continue
#print("- ", s)
tagNameA = ''.join([
random.choice('abcdefghijklmnopqrstuvwxyz') for _ in range(10)
])
L_Size = self.FONT_SIZE # if solution[i] == 1 else 10
L_Colour = self.fg_solution_article if solution[
i] == 1 else self.fg_min_article
#print("\t", L_Colour)
countVar = StringVar(self.root)
pos = self.tk_article.search(s,
"1.0",
stopindex="end",
count=countVar)
self.tk_article.tag_add(tagNameA, pos,
"{} + {}c".format(pos, countVar.get()))
bolding = "normal" #"bold" if self.solution[i] == 1 else "normal" #
font = (self.FONT, L_Size, bolding)
self.tk_article.tag_config(tagNameA,
foreground=toHex(L_Colour),
font=font) #self.FONT+' %s'%(L_Size))
self.root.update()
text.configure(state="disabled")
root = Tk()
root.configure(background='teal')
root.title("Syntactic Textual Similarity")
root.resizable(width=False, height=False)
note = Notebook(root)
frame = Frame(root)
queryvar = StringVar()
ql = StringVar()
frame.grid(row=4,column=0,rowspan=12,columnspan=3,pady=20)
text = ScrolledText(frame,wrap="word")
text.grid(row=4)
text.config(font=("Courier", 12))
text.configure(background='black',foreground='green')
directory = StringVar()
filename = StringVar()
sent1 = StringVar()
sent2 = StringVar()
status = StringVar()
modelnum = StringVar()
status.set("")
filename.set("")
Label(root,textvariable=status,bg='teal',foreground='white').grid(row=0,column=1,padx=(20),pady=(20),columnspan=6)
Label(root,text="Directory:",bg='teal',foreground='white').grid(row=2,column=0,padx=(10),pady=(10))
Entry(root,text=directory,bd=2,bg='#cfacaf',width='75').grid(row=2,column=1)
Button(root,command=browseDestDir,text='Browse').grid(row=2,column=2,padx=20)
class ttkTestApplication(ttk.Frame):
"""
This class for design a Test Pad
"""
_adb = None
_entry = None
_text = None
def __init__(self, master=None):
self._adb = AdbUnit.AdbUnit()
ttk.Frame.__init__(self, master, class_='ttktestApplication')
#Set the windows title
title = 'mobileco '+ __version__+ '-Test'
self.master.title(title)
self.create_test()
#Set the pad position
master.geometry("+%d+%d" % (300, 200))
self.grid()
def create_test(self):
"""
Build widgets for pad
"""
#add test button
cl = 0
for bn in ['enginner','gps','validation','test','catlog','setting']:
g_button = ttk.Button(self,name = bn,text = bn)
g_button.bind('<ButtonRelease-1>', self._test_func)
g_button.grid(row = 0,column = cl)
cl +=1
#add command line
t = ttk.Label(self,text = "命令：")
t.grid(row = 1,column = 0)
self._entry = ttk.Entry(self,width = 25)
self._entry.grid(row = 1,column = 1,columnspan=cl-1)
self._entry.bind("<Return>",self.get_cmd)
self._text = ScrolledText(self,width = cl*10,height = 20)
self._text.grid(row = 2,column =0,columnspan =cl)
self.master.bind('<Configure>',self.resize)
pass
def get_cmd(self,event):
"""
Get the Entry text for cmd ,And send to mobile
"""
str_cmd = event.widget.get()
self.show_respon("youjin# "+ str_cmd + '\n')
self._entry.delete('0','end')
self._entry.update()
rep = self._adb.adbshellcommand(str_cmd)
if rep is None:
rep = "more than one device and emulator"
self.show_respon("adb#"+ rep )
self._text.configure(width = 50,height = 30)
def show_respon(self,str):
"""
Place the text in a Text widget for show
"""
self._text.insert('end',str)
self._text.yview_moveto(1)
pass
def _test_func(self,event):
"""
implement the Fix button widget function
"""
bn = event.widget.winfo_name()
print bn
cmd = "none"
if bn == "enginner":
cmd = "am start -n com.sprd.engineermode/.EngineerModeActivity"
pass
elif bn == "gps":
cmd = "am start -n com.spreadtrum.sgps/.SgpsActivity"
pass
elif bn == "validation":
cmd = "am start -n com.sprd.validationtools/.ValidationToolsMainActivity"
pass
elif bn == "test":
cmd = "input keyevent 60;am force-stop test.zhlt.g1;am start -n test.zhlt.g1/.TestActivity"
pass
elif bn == "catlog":
cmd = "cat /sdcard/test.log"
pass
elif bn == "setting":
cmd = "am start -n com.android.settings/com.android.settings.Settings"
pass
if self._adb.device_exist():
self.show_respon(cmd)
rep = self._adb.adbshellcommand(cmd)
self.show_respon(rep)
pass
def resize(self,event):
print event.width,' ',event.height
pass
class PackageInstallDlg(Frame):
def __init__(self, master=None, width=0, height=0):
Frame.__init__(self, master)
self.createdlg()
def createdlg(self):
global nWindowWidth, nWindowHeight
# window title
self.master.title('PackageInstall_Tool %s' % (g_StrVersion))
self.pack(fill=BOTH,
expand=1) # expand = 1 can use fix ,and fill has x AND y AND both,3 parameters,both will expand to x and y ,when expand your GUI
self.master.iconbitmap(r'Install.ico')
self.master.protocol('WM_DELETE_WINDOW',
self.on_closing) # define the DELETE_WINDOW ACTION is on_closing activity
nWindowWidth, nWindowHeight = (self.winfo_screenwidth() * 3 / 4), (self.winfo_screenheight() * 3 / 4)
nWindowsPosX = (self.winfo_screenwidth() / 2) - (nWindowWidth / 2)
nWindowsPosY = (self.winfo_screenheight() / 2) - (nWindowHeight / 2)
self.master.minsize(width=nWindowWidth, height=nWindowHeight)
self.master.maxsize(width=nWindowWidth, height=nWindowHeight)
self.master.geometry("+%d+%d" % (nWindowsPosX, nWindowsPosY))
self.showReportBox()
self.showExitBtn()
self.showCheckFrame()
self.showPackageCheckBox()
self.showInstallBtn()
self.showResetBtn()
self.showStatus()
self.checkPIP()
# print self.winfo_screenwidth()
# print nWindowWidth
# print nWindowHeight
# print nWindowsPosX
# print nWindowsPosY
def checkPIP(self):
self.printResult("[I] Check PIP Version....\n")
self.inputControl("Lock")
self.changeRunningState("Running")
threading.Thread(target=installPIP).start() # Define Function installPIP
# Result box generate
def showReportBox(self):
self.ResultBoxLabel = Label(self, text="Status Log:", anchor='w', foreground="#000080")
self.ResultBoxLabel['font'] = ("Microsoft JhengHei", 16, "bold")
self.ResultBoxLabel.place(x=nWindowWidth * 40 / 80, y=nWindowHeight * 2 / 80, width=nWindowWidth * 40 / 80,
height=nWindowHeight * 4 / 80)
self.ResultBox = ScrolledText(self, state=DISABLED, foreground="#000080") # Load ScrolledText from dll
self.ResultBox.place(x=nWindowWidth * 40 / 80, y=nWindowHeight * 6 / 80, width=nWindowWidth * 39 / 80,
height=nWindowHeight * 60 / 80)
def showExitBtn(self):
self.ExitBtn = Button(self, text="Exit", command=self.exitButtonDlg, foreground="#000080")
self.ExitBtn.place(x=nWindowWidth * 68 / 80, y=nWindowHeight * 69 / 80, width=nWindowWidth * 10 / 80, height=nWindowHeight * 8 / 80)
self.ExitBtn['font'] = ("Microsoft JhengHei", 18, "bold")
def showResetBtn(self):
self.retBtn = Button(self, text="Reset", command=self.resetButtonDlg, foreground="#000080")
self.retBtn.place(x=nWindowWidth * 55 / 80, y=nWindowHeight * 69 / 80, width=nWindowWidth * 10 / 80, height=nWindowHeight * 8 / 80)
self.retBtn['font'] = ("Microsoft JhengHei", 18, "bold")
def resetButtonDlg(self):
if tkMessageBox.askokcancel("Reset", "Do you want to reset and continue to start install !"):
self.inputControl("UnLock")
self.changeRunningState("Ready")
def exitButtonDlg(self):
if tkMessageBox.askokcancel("Quit", "Do you want to close the window!"):
self.master.destroy()
def on_closing(self):
if tkMessageBox.askokcancel("Quit", "Do you want to close the windows?"): # tkMessageBox.xxxxx(title, message, options)
self.master.destroy()
def showCheckFrame(self):
self.CheckFrame = LabelFrame(self, text="-.-.- Package List -.-.-", labelanchor="n", foreground="orange")
self.CheckFrame['font'] = ("Microsoft JhengHei", 16, "bold")
self.CheckFrame.place(x=nWindowWidth * 2 / 80, y=nWindowHeight * 10 / 80, width=nWindowWidth * 37 / 80,
height=nWindowHeight * 65 / 80)
# Package List Check Box generate
def showPackageCheckBox(self):
global CheckVar
CheckVar = []
self.ListCheckbox = []
for PackageShowListIndex in range(len(PackageShowList)):
self.var = IntVar()
##############################
self.ListCheckbox.append(Checkbutton(self, text=str(
RefinePackageShowList[PackageShowListIndex][0]) + " [ version: " + str(
RefinePackageShowList[PackageShowListIndex][1]) + " ] ", variable=self.var, anchor="w"))
CheckVar.append(self.var)
self.ListCheckbox[PackageShowListIndex].place(x=nWindowWidth * 3 / 80, y=(nWindowHeight * 14 / 80) + (
PackageShowListIndex * nWindowHeight * 9 / 320), width=nWindowWidth * 20 / 80,
height=nWindowHeight * 2 / 80)
self.printResult("List check box has Initialed\n")
printLog("[I][showPackageCheckBox] Checkbox successfully generate")
# Check and Uncheck and install button
def showInstallBtn(self):
self.checkAllBtn = Button(self, text="Select All", command=self.checkAll, foreground="#000080")
self.checkAllBtn.place(x=nWindowWidth * 4 / 80, y=nWindowHeight * 65 / 80, width=nWindowWidth * 15 / 80,
height=nWindowHeight * 8 / 80)
self.checkAllBtn['font'] = ("Microsoft JhengHei", 18, "bold")
self.uncheckAllBtn = Button(self, text="Unselect All", command=self.uncheckAll, foreground="#000080")
self.uncheckAllBtn.place(x=nWindowWidth * 22 / 80, y=nWindowHeight * 65 / 80, width=nWindowWidth * 15 / 80,
height=nWindowHeight * 8 / 80)
self.uncheckAllBtn['font'] = ("Microsoft JhengHei", 18, "bold")
self.InstallBtn = Button(self, text="Start Install", command=self.installBtn, foreground="#af0000")
self.InstallBtn.place(x=nWindowWidth * 40 / 80, y=nWindowHeight * 69 / 80, width=nWindowWidth * 12 / 80,
height=nWindowHeight * 8 / 80)
self.InstallBtn['font'] = ("Microsoft JhengHei", 18, "bold")
def checkAll(self):
for i in self.ListCheckbox:
i.select()
def uncheckAll(self):
for i in self.ListCheckbox:
i.deselect()
self.changeRunningState("UnSelect")
def installBtn(self):
self.changeRunningState("Running")
self.printResult("Install is running...\n")
self.inputControl("Lock")
threading.Thread(target=self.startInstalling).start()
# Status label text and place
def showStatus(self):
self.StatusText = Label(self, text="State: ", foreground="#000080")
self.StatusText['font'] = ("Microsoft JhengHei", 26, "bold")
self.StatusText.place(x=nWindowWidth * 2 / 80, y=nWindowHeight * 1 / 80, width=nWindowWidth * 8 / 80,
height=nWindowHeight * 8 / 80)
self.StatusLabel = Label(self, text="Ready...... ", bg="green")
self.StatusLabel['font'] = ("Microsoft JhengHei", 26, "bold")
self.StatusLabel.place(x=nWindowWidth * 10 / 80, y=nWindowHeight * 1 / 80, width=nWindowWidth * 16 / 80,
height=nWindowHeight * 8 / 80)
# Status Label change Function
def changeRunningState(self, RunningorReady):
if RunningorReady == "Running":
self.printResult("Clicked installbtn,Ready Install...\n")
self.StatusLabel.destroy()
self.StatusLabel = Label(self, text="Running", bg="red")
self.StatusLabel.place(x=nWindowWidth * 5 / 40, y=nWindowHeight * 1 / 80, width=nWindowWidth * 8 / 40)
self.StatusLabel['font'] = ("Microsoft JhengHei", 26, "bold")
if RunningorReady == "Ready":
self.printResult("Getting on ready...\n")
self.StatusLabel.destroy()
self.StatusLabel = Label(self, text="Ready", bg="green")
self.StatusLabel.place(x=nWindowWidth * 5 / 40, y=nWindowHeight * 1 / 80, width=nWindowWidth * 8 / 40)
self.StatusLabel['font'] = ("Microsoft JhengHei", 26, "bold")
if RunningorReady == "Finish":
self.printResult("Process has finished...\n")
self.StatusLabel.destroy()
self.StatusLabel = Label(self, text="Finish", bg="blue")
self.StatusLabel.place(x=nWindowWidth * 5 / 40, y=nWindowHeight * 1 / 80, width=nWindowWidth * 8 / 40)
self.StatusLabel['font'] = ("Microsoft JhengHei", 26, "bold")
if RunningorReady == "UnSelect":
self.printResult("You Clicked Unselect command...\n")
self.StatusLabel.destroy()
self.StatusLabel = Label(self, text="UnSelect", bg="yellow")
self.StatusLabel.place(x=nWindowWidth * 5 / 40, y=nWindowHeight * 1 / 80, width=nWindowWidth * 8 / 40)
self.StatusLabel['font'] = ("Microsoft JhengHei", 26, "bold")
def inputControl(self, L_state):
if L_state == "Lock":
for item in self.ListCheckbox:
item["state"] = "disabled"
self.checkAllBtn['state'] = 'disabled'
self.uncheckAllBtn['state'] = 'disabled'
self.InstallBtn['state'] = 'disabled'
if L_state == "UnLock":
for item in self.ListCheckbox:
item["state"] = "normal"
self.checkAllBtn['state'] = 'normal'
self.uncheckAllBtn['state'] = 'normal'
self.InstallBtn['state'] = 'normal'
# Result box status input
def printResult(self, str_Info):
self.ResultBox.configure(state='normal')
self.ResultBox.insert(END, str_Info)
self.ResultBox.configure(state='disabled')
def startInstalling(self):
for i in range(len(PackageShowList)):
if CheckVar[i].get() == 1:
PackageInstallDlg.printResult("[I] Searching " + PackageShowList[i] + " requirement...\n")
for index in range(len(g_PackageRequirementList)):
# requirement in show list
if g_PackageRequirementList[index][0] in PackageShowList[i]:
for innerindex in range(len(g_PackageRequirementList[index][1])):
for j in range(len(RequirementList)):
if g_PackageRequirementList[index][1][innerindex] in RequirementList[j]:
PackageInstallDlg.printResult("[I] Installing: " + RequirementList[j] + "\n")
installpackage(RequirementList[j])
PackageInstallDlg.printResult("[I] Installing: " + PackageShowList[i] + "\n")
installpackage(PackageShowList[i])
print "end"
# State labe change
self.changeRunningState("Finish")
self.printResult("╔═══════════════╗\n")
self.printResult("║ F i n i s h ! ║\n")
self.printResult("╚═══════════════╝\n")
def load_gui():
global browserwindow
global text
global input_file_var
global output_file_var
global config_file_var
global training_percent_entry
global n_layers_entry
global epoch_entry
global dropout_fraction_ru_entry
global dropout_fraction_rw_entry
global optimizer_variable
global err_metric_variable
global layer_dimension_entry
global learning_rate_entry
global momentum_entry
global check_marked
browserwindow = Tk()
browserwindow.wm_title("LSTM tool v0.1.1")
browserwindow.resizable(width=True, height=True)
#FRAMES
parameters_frame = Frame(browserwindow, width=700, height=700)
output_frame = Frame(browserwindow)
parameters_frame.pack_propagate(False)
#output_frame.pack_propagate(False)
#Packing containing FRAMES
parameters_frame.pack(side=LEFT)
output_frame.pack(side=TOP)
#output text in output_frame
text = ScrolledText(output_frame,
width=100,
height=45,
insertborderwidth=3,
background="black",
fg="lightgreen")
text.configure(state="disabled")
text.pack()
utility_button_frame = Frame(output_frame)
clear_button = Button(utility_button_frame,
text="Delete Result Buffer",
width="25",
command=clear)
utility_button_frame.pack(side=TOP)
clear_button.grid(row=0)
#parameters input frames and Packing
heading_frame = Frame(parameters_frame)
heading_label = Label(heading_frame, text="PARAMETER(S) :")
sub_heading_label = Label(heading_frame,
text="All fields marked with (*) are required",
fg="red")
filename_frame = Frame(parameters_frame)
filename_label = Label(filename_frame, text="Load input filename (*) : ")
filename_load_button = Button(filename_frame,
text="Browse",
width="10",
command=fetch_training_file)
input_file_var = StringVar()
input_file_var.set("")
file_frame = Frame(parameters_frame)
file_label = Label(file_frame, textvariable=input_file_var, fg="blue")
output_filename_frame = Frame(parameters_frame)
ouput_filename_label = Label(output_filename_frame,
text="Save output filename as (*) : ")
output_filename_load_button = Button(output_filename_frame,
text="Browse",
width="10",
command=fetch_output_file)
output_file_var = StringVar()
output_file_var.set("")
output_file_frame = Frame(parameters_frame)
output_file_label = Label(output_file_frame,
textvariable=output_file_var,
fg="blue")
sub_parameter_frame = Frame(parameters_frame)
training_percent = DoubleVar()
training_percent_label = Label(sub_parameter_frame,
text="Training percentage : ")
training_percent_entry = Entry(sub_parameter_frame,
width=10,
textvariable=training_percent)
training_percent.set(0.7)
layers = IntVar()
n_layers_label = Label(sub_parameter_frame, text="Number of layers : ")
n_layers_entry = Entry(sub_parameter_frame, width=10, textvariable=layers)
layers.set(3)
epoch = IntVar()
epoch_label = Label(sub_parameter_frame, text="Epoch : ")
epoch_entry = Entry(sub_parameter_frame, width=10, textvariable=epoch)
epoch.set(100)
output_ru_layers = DoubleVar()
dropout_fraction_ru_label = Label(
sub_parameter_frame,
text="Fraction of R_Units to be dropped [0.0, 1.0) : ")
dropout_fraction_ru_entry = Entry(sub_parameter_frame,
width=10,
textvariable=output_ru_layers)
output_ru_layers.set(0.0)
output_rw_layers = DoubleVar()
dropout_fraction_rw_label = Label(
sub_parameter_frame,
text="Fraction of input units to be dropped [0.0, 1.0) : ")
dropout_fraction_rw_entry = Entry(sub_parameter_frame,
width=10,
textvariable=output_rw_layers)
output_rw_layers.set(0.0)
optimizer_label = Label(sub_parameter_frame, text="Optimizer type :")
OPTIMIZER_OPTIONS = ["adam", "SGD", "RMSprop", "nadam"]
optimizer_variable = StringVar(sub_parameter_frame)
optimizer_variable.set(OPTIMIZER_OPTIONS[0])
optimizer_dropdown = apply(OptionMenu,
(sub_parameter_frame, optimizer_variable) +
tuple(OPTIMIZER_OPTIONS))
optimizer_dropdown.config(width=10)
err_metric_label = Label(sub_parameter_frame, text="Error Metric :")
ERROR_METRIC_OPTIONS = ["MSE"]
err_metric_variable = StringVar(sub_parameter_frame)
err_metric_variable.set(ERROR_METRIC_OPTIONS[0])
err_metric_dropdown = apply(OptionMenu,
(sub_parameter_frame, err_metric_variable) +
tuple(ERROR_METRIC_OPTIONS))
err_metric_dropdown.config(width=10)
dimension = StringVar()
layer_dimension_label = Label(
sub_parameter_frame,
text="Layer dimensions [LAYERDIM1,LAYERDIM2,...] : ")
layer_dimension_entry = Entry(sub_parameter_frame,
width=10,
textvariable=dimension)
dimension.set("1,4,1")
learning_rate_label = Label(sub_parameter_frame,
text="Learning rate (*) : ")
learning_rate_entry = Entry(sub_parameter_frame, width=10)
momentum = DoubleVar()
momentum_label = Label(sub_parameter_frame, text="Momentum : ")
momentum_entry = Entry(sub_parameter_frame,
width=10,
textvariable=momentum)
momentum.set(0.0)
append_label = Label(sub_parameter_frame,
text="Append run configuration to logfile")
check_marked = IntVar()
append_check_button = Checkbutton(sub_parameter_frame,
variable=check_marked,
onvalue=1,
offvalue=0)
config_cover_frame = Frame(parameters_frame)
config_cover_frame.configure(pady=8)
config_filename_frame = Frame(config_cover_frame)
config_filename_label = Label(config_filename_frame,
text="Use config file : ")
config_filename_load_button = Button(config_filename_frame,
text="Browse",
width="10",
command=fetch_config_file)
config_filename_delete_button = Button(config_filename_frame,
text="Delete Config",
width="15",
command=delete_config_file)
config_file_var = StringVar()
config_file_var.set("")
config_file_frame = Frame(config_cover_frame)
config_file_label = Label(config_file_frame,
textvariable=config_file_var,
fg="blue")
save_button_frame = Frame(parameters_frame)
save_button_label = Label(save_button_frame, text="Save config : ")
save_button = Button(save_button_frame,
text="Save Config",
width="15",
command=save_as_config_file)
buttons_frame = Frame(parameters_frame)
run_button = Button(parameters_frame,
text="Run",
width="10",
command=validate_execute)
masthead_frame = Frame(parameters_frame)
masthead_frame.config(pady=40)
masthead_label = Label(
masthead_frame,
text="Developed by Abhishek Jain, Pradyumna Kaushik and Sreedhar Kumar"
)
instruction_label = Label(
parameters_frame,
text="Upload config JSON file or fill the configurations below",
fg="red")
#packing inner frames,entries and buttons
heading_frame.pack(side=TOP)
heading_label.pack()
sub_heading_label.pack()
instruction_label.pack()
filename_frame.pack(side=TOP)
filename_label.grid(row=2)
filename_load_button.grid(row=2, column=1)
file_frame.pack(side=TOP)
file_label.pack(side=LEFT)
output_filename_frame.pack(side=TOP)
ouput_filename_label.grid(row=3)
output_filename_load_button.grid(row=3, column=1)
output_file_frame.pack(side=TOP)
output_file_label.pack(side=LEFT)
config_cover_frame.pack(side=TOP)
config_filename_frame.pack(side=TOP)
config_filename_label.grid(row=4)
config_filename_load_button.grid(row=4, column=1)
config_filename_delete_button.grid(row=4, column=2)
config_file_frame.pack(side=TOP)
config_file_label.pack(side=LEFT)
sub_parameter_frame.pack()
training_percent_label.grid(row=6)
training_percent_entry.grid(row=6, column=1)
n_layers_label.grid(row=7)
n_layers_entry.grid(row=7, column=1)
epoch_label.grid(row=8)
epoch_entry.grid(row=8, column=1)
dropout_fraction_ru_label.grid(row=9)
dropout_fraction_ru_entry.grid(row=9, column=1)
dropout_fraction_rw_label.grid(row=10)
dropout_fraction_rw_entry.grid(row=10, column=1)
optimizer_label.grid(row=11)
optimizer_dropdown.grid(row=11, column=1)
err_metric_label.grid(row=12)
err_metric_dropdown.grid(row=12, column=1)
layer_dimension_label.grid(row=13)
layer_dimension_entry.grid(row=13, column=1)
learning_rate_label.grid(row=14)
learning_rate_entry.grid(row=14, column=1)
momentum_label.grid(row=15)
momentum_entry.grid(row=15, column=1)
append_label.grid(row=16)
append_check_button.grid(row=16, column=1)
save_button_frame.pack(side=TOP)
save_button_label.pack(side=LEFT)
save_button.pack(side=RIGHT)
buttons_frame.pack(side=TOP)
run_button.pack()
save_button.pack()
masthead_frame.pack()
masthead_label.pack(side=BOTTOM)
#Run the GUI browserwindow mainloop
browserwindow.mainloop()
