class Scratchpad:
def __init__(self):
self.window = Tk()
self.window.title("Onager Scratchpad")
self.create_frame()
self.create_editing_window()
self.window.bind('<F7>', self.save_file)
self.window.bind('<F5>', self.open_file)
def create_frame(self):
frame_style = Style()
frame_style.theme_use('alt')
frame_style.configure("TFrame",
relief='raised')
self.frame = Frame(self.window, style="frame_style.TFrame")
self.frame.rowconfigure(1)
self.frame.columnconfigure(1)
self.frame.grid(row=0, column=0)
def create_editing_window(self):
self.editing_window = ScrolledText(self.frame)
self.editing_window.configure(fg='gold',
bg='blue',
font='serif 12',
padx='15',
pady='15',
wrap='word',
borderwidth='10',
relief='sunken',
tabs='48',
insertbackground='cyan')
self.editing_window.grid(row=0, column=0)
def save_file(self, event=None):
name = asksaveasfilename()
outfile = open(name, 'w')
contents = self.editing_window.get(0.0, END)
outfile.write(contents)
outfile.close()
def open_file(self, event=None):
name = askopenfilename()
infile = open(name, 'r')
contents = infile.read()
self.editing_window.insert(INSERT, contents)
infile.close()
class MessageTester:
def __init__(self, root):
root.title("Message tester")
Label(root, text="Enter message event below", bg="light green").pack()
self.event_field = ScrolledText(root, width=180, height=10)
self.event_field.pack()
Label(root, text="Enter test case below", bg="light green").pack()
self.test_case_field = ScrolledText(root, width=180, height=20)
self.test_case_field.pack()
Label(root, text="Test result:", bg="light green").pack()
self.result_field = ScrolledText(root, width=180, height=10)
self.result_field.pack()
self.result_field.config(state=DISABLED)
self.button = Button(root, text="Evaluate", fg="red",
command=self._clicked)
self.button.pack()
self.event_field.delete('1.0', END)
self.event_field.insert('insert', EXAMPLE_EVENT)
self.test_case_field.delete('1.0', END)
self.test_case_field.insert('insert', EXAMPLE_TEST_CASE)
def _clicked(self):
event = self.event_field.get('1.0', END)
test_case = self.test_case_field.get('1.0', END)
evaluation = skill_tester.EvaluationRule(ast.literal_eval(test_case))
evaluation.evaluate(ast.literal_eval(event))
self.result_field.config(state=NORMAL)
self.result_field.delete('1.0', END)
self.result_field.insert('insert', evaluation.rule)
self.result_field.config(state=DISABLED)
class MessageTester:
def __init__(self, root):
root.title("Message tester")
Label(root, text="Enter message event below", bg="light green").pack()
self.event_field = ScrolledText(root, width=180, height=10)
self.event_field.pack()
Label(root, text="Enter test case below", bg="light green").pack()
self.test_case_field = ScrolledText(root, width=180, height=20)
self.test_case_field.pack()
Label(root, text="Test result:", bg="light green").pack()
self.result_field = ScrolledText(root, width=180, height=10)
self.result_field.pack()
self.result_field.config(state=DISABLED)
self.button = Button(root, text="Evaluate", fg="red",
command=self._clicked)
self.button.pack()
self.event_field.delete('1.0', END)
self.event_field.insert('insert', EXAMPLE_EVENT)
self.test_case_field.delete('1.0', END)
self.test_case_field.insert('insert', EXAMPLE_TEST_CASE)
def _clicked(self):
event = self.event_field.get('1.0', END)
test_case = self.test_case_field.get('1.0', END)
evaluation = skill_tester.EvaluationRule(ast.literal_eval(test_case))
evaluation.evaluate(ast.literal_eval(event))
self.result_field.config(state=NORMAL)
self.result_field.delete('1.0', END)
self.result_field.insert('insert', evaluation.rule)
self.result_field.config(state=DISABLED)
class TextEditor(): # see PyEdit for more
def __init__(self, parent=None):
# TODO: 1226 why This can generate independent window ?
#frm=Toplevel(Frame.__init__(self, parent))
frm=Toplevel()
# TODO : assign title based on cmdline tag
frm.title('New Text')
# TODO , how to make button and Text in a better Layout format ?
# grid() param to learn
Button(frm, text='Save', command=self.onSave).grid(row=0,column=0)
Button(frm, text='Cut', command=self.onCut).grid(row=0,column=1)
Button(frm, text='Paste', command=self.onPaste).grid(row=0,column=2)
Button(frm, text='Find', command=self.onFind).grid(row=0,column=3)
self.text = ScrolledText(frm)
self.text.grid(row=1,columnspan=4)
#Button(self, text='Save', command=self.onSave).grid()
#Button(self, text='Cut', command=self.onCut).grid()
#Button(self, text='Paste', command=self.onPaste).grid()
#Button(self, text='Find', command=self.onFind).grid()
#self.text = ScrolledText(self)
def gettext(self): # returns a string
return self.text.get('1.0', END+'-1c') # first through last
def onSave(self):
filename = asksaveasfilename()
#print(filename)
if filename:
alltext = self.gettext() # first through last
open(filename, 'w').write(alltext) # store text in file
def onCut(self):
text = self.text.get(SEL_FIRST, SEL_LAST) # error if no select
self.text.delete(SEL_FIRST, SEL_LAST) # should wrap in try
self.text.clipboard_clear()
self.text.clipboard_append(text)
def onPaste(self): # add clipboard text
try:
text = self.text.selection_get(selection='CLIPBOARD')
self.text.insert(INSERT, text)
except TclError:
pass # not to be pasted
def onFind(self):
target = askstring('SimpleEditor', 'Search String?')
if target:
where = self.text.search(target, INSERT, END) # from insert cursor
if where: # returns an index
print(where)
pastit = where + ('+%dc' % len(target)) # index past target
#self.text.tag_remove(SEL, '1.0', END) # remove selection
self.text.tag_add(SEL, where, pastit) # select found target
self.text.mark_set(INSERT, pastit) # set insert mark
self.text.see(INSERT) # scroll display
self.text.focus() # select text widget
class MainPage(tk.Frame):
'''
This is all the content on the main page
'''
def __init__(self, parent, controller):
''' Constructor '''
# Call the parents constructor
tk.Frame.__init__(self, parent)
self.parent = parent
self.controller = controller
self.name = "MainPage"
# Add the content
# Fill the whole window with a text box to be typed into
self.textArea = ScrolledText(self)
self.textArea.pack(side="top", fill="both", expand=True)
self.textArea.insert(tk.INSERT, self.controller.content)
# Create the menubar and add it to the parent window
self.menubar = tk.Menu(self.controller)
self.set_menubar = lambda: self.controller.config(menu=self.menubar)
# Create a 'file' menu
self.fileMenu = tk.Menu(self.menubar)
self.fileMenu.add_command(label="New", command=self.controller.create_new)
self.fileMenu.add_command(label="Open", command=
lambda: self.controller.create_new(self.controller.open_file())
)
self.fileMenu.add_command(label="Save", command=
lambda: self.controller.save_file(self.textArea.get(1.0,tk.END),True)
)
self.fileMenu.add_command(label="Save As", command=
lambda: self.controller.save_file(self.textArea.get(1.0,tk.END))
)
self.fileMenu.add_command(label="Quit", command=self.controller.quit)
# Create a 'run' menu
self.runMenu = tk.Menu(self.menubar)
self.runMenu.add_command(label="Run Script", command=self.controller.run)
# Create a 'help' menu
self.helpMenu = tk.Menu(self.menubar)
self.helpMenu.add_command(label="PigeonScript Docs", command=None)
# Add the file menu to the window
self.menubar.add_cascade(label="File", menu=self.fileMenu)
self.menubar.add_cascade(label="Run", menu=self.runMenu)
self.menubar.add_cascade(label="Help", menu=self.helpMenu)
class Pynote:
def __init__(self, root):
self.root = root
menubar = Menu(root)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='New', command=self.new_file)
filemenu.add_command(label='Open', command=self.open_file)
filemenu.add_command(label='Save', command=self.save)
filemenu.add_command(label='Save As', command=self.save_as)
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)
menubar.add_cascade(label="File", menu=filemenu)
self.root.config(menu=menubar)
self.textarea = ScrolledText(self.root, undo=True, wrap=WORD)
self.textarea.place(relwidth=1, relheight=1)
def new_file(self, *args):
self.textarea.delete(1.0, END)
self.filename = None
def open_file(self, *args):
self.filename = filedialog.askopenfilename(defaultextension=".txt",
filetypes=[("All Files", "*.*"), ("Text Files", "*.txt"),
("Python Scripts", "*.py"), ("HTML Documents", "*.html")])
if self.filename:
self.textarea.delete(1.0, END)
with open(self.filename, "r") as f:
self.textarea.insert(1.0, f.read())
def save(self, *args):
self.filename= filedialog.asksaveasfilename(defaultextension=".txt",
filetypes=[("All Files", "*.*"), ("Text Files", "*.txt"),
("Python Scripts", "*.py"), ("HTML Documents", "*.html")])
if self.filename:
try:
textarea_content = self.textarea.get(1.0, END)
with open(self.filename, "w") as f:
f.write(textarea_content)
except Exception as e:
print(e)
else:
self.save_as()
def save_as(self, *args):
try:
new_file = filedialog.askopenfilename(initialfile="Untitled.txt", defaultextension=".txt",
filetypes=[("All Files", "*.*"), ("Text Files", "*.txt"),
("Python Scripts", "*.py"), ("HTML Documents", "*.html")])
textarea_content = self.textarea.get(1.0, END)
with open(new_file, "w") as f:
f.write(textarea_content)
except Exception as e:
print(e)
def render_create_view():
clear_view()
Label(tk, text="Enter your task's name:").grid(column=0, row=0, padx=20, pady=20)
task_name = Entry(tk)
task_name.grid(column=1, row=0, padx=20, pady=20)
Label(tk, text="Enter your task's description:").grid(column=0, row=1, padx=20, pady=20)
task_description = ScrolledText(tk, width =20, height=10)
task_description.grid(column=1, row=1, padx=20, pady=20)
Label(tk, text="Enter your task's priority:").grid(column=0, row=2, padx=20, pady=20)
task_priority = IntVar()
radio_button_1 = Radiobutton(tk, text="Low", value=1, variable=task_priority)
radio_button_2 = Radiobutton(tk, text="Medium", value=2, variable=task_priority)
radio_button_3 = Radiobutton(tk, text="High", value=3, variable=task_priority)
radio_button_1.grid(column=1, row=2, padx=20, pady=20)
radio_button_2.grid(column=2, row=2, padx=20, pady=20)
radio_button_3.grid(column=3, row=2, padx=20, pady=20)
Label(tk, text="Is the task completed?:").grid(column=0, row=3, padx=20, pady=20)
task_completed = BooleanVar()
check_box = Checkbutton(tk, variable=task_completed)
check_box.grid(column=1, row=3, padx=20, pady=20)
Button(tk, text="Create task", bg="green", fg="white",
command=lambda: create_task(task_name.get(), task_description.get("1.0", END),
task_priority.get(), task_completed.get()))\
.grid(column=0, row=4)
Button(tk, text="Cancel", bg="black", fg="white",
command=render_main_view).grid(column=1, row=4)
class BasicGUI(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.text_pad = ScrolledText(master, width=100, height=80)
self.menu = Menu(self.master)
self.master.config(menu=self.menu)
filemenu_commands = [('Open...', self.open_command),
('Save', self.save_command), ('', ''),
('Exit', self.exit_command)]
self.add_menu_to_main_menu('File', filemenu_commands)
helpmenu_commands = [('About...', self.about_command)]
self.add_menu_to_main_menu('Help', helpmenu_commands)
def open_command(self, file_name=None):
if file_name is None:
file = filedialog.askopenfile(parent=self.master,
mode='r',
title='Select a file')
else:
file = open(file_name, 'r')
if file is not None:
print('Opening {}'.format(file.name))
contents = file.read()
self.text_pad.insert('1.0', contents)
file.close()
def save_command(self):
file = filedialog.asksaveasfile(mode='w')
if file is not None:
data = self.text_pad.get('1.0', tk.END + '-1c')
file.write(data)
file.close()
def exit_command(self):
if messagebox.askokcancel('Quit', 'Do you really want to quit?'):
self.master.destroy()
@staticmethod
def about_command():
messagebox.showinfo(
'About', 'Just Another TextPad \n '
'Copyright \n '
'HPL, University of Colorado, Anschutz Medical Campus. 2017')
def add_menu_to_main_menu(self, name, commands):
newmenu = Menu(self.menu)
self.menu.add_cascade(label=name, menu=newmenu)
for label, command in commands:
if label is '':
newmenu.add_separator()
else:
newmenu.add_command(label=label, command=command)
def run(self):
self.text_pad.pack()
self.master.state('zoomed')
self.master.mainloop()
class App:
def __init__(self, master=None):
self.root = master
self.root.title("Musicas")
self.root.geometry("230x260")
self.frame = Frame(self.root)
self.msg = Label(
self.frame,
text="Insira as músicas que \ndeseja baixar no \ncampo abaixo",
font=("Arial", "12"))
self.msg.grid(row=1, column=1)
self.scrolled = ScrolledText(self.frame, width=25, height=10)
self.scrolled.grid(row=2, column=1)
self.button = Button(self.frame,
text="Enviar",
command=self.sair,
font=("Arial", "12"),
width=5,
height=1)
self.button.grid(row=3, column=1)
self.frame.pack()
def sair(self):
with open("musicas.txt", "w") as file:
file.write(self.scrolled.get(1.0, END))
self.root.destroy()
def abrirTreino(self, alunoId):
treino = self.treino.procurar({"alunoId": alunoId, "professorId": self.sessao["id"]})
root = Tk()
root.geometry("500x500")
texto = ScrolledText(root)
texto.pack()
if treino == None:
Button(root, text="Salvar", command= lambda: [self.treino.cadastrar({
"texto": texto.get(1.0, END),
"alunoId": alunoId,
"professorId": self.sessao["id"]
}), root.destroy()]).pack(pady=25)
else:
texto.insert(INSERT, treino["texto"])
Button(root, text="Salvar", command= lambda: [self.treino.atualizar({
"texto": texto.get(1.0, END),
"treinoId": treino["id"]
}), root.destroy()]).pack(pady=25)
root.mainloop()
def editContactView(self, infoWindow, Contact):
window = Toplevel()
window.focus_set()
window.title("Edit Contact")
window.resizable(width=FALSE, height=FALSE)
Label(window, text="Name ").grid(row=0, column=0)
name = Entry(window, width=30)
name.grid(row=0, column=1)
name.insert(0, Contact["name"])
Label(window, text="Line ").grid(row=1, column=0)
line = Entry(window, width=30)
line.grid(row=1, column=1)
line.insert(0, Contact["line"])
Label(window, text="Email ").grid(row=2, column=0)
Email = Entry(window, width=30)
Email.grid(row=2, column=1)
Email.insert(0, Contact["Email"])
Label(window, text="Phone ").grid(row=3, column=0)
telephone = ScrolledText(window, width=37)
telephone.grid(row=3, column=1)
for i in Contact["telephone"]:
telephone.insert(INSERT, str(i) + "\n")
okButton = Button(window, text="Finish",
command=lambda: self.editContact(window, infoWindow, uuid=Contact["uuid"], name=name.get(),
line=line.get(),
Email=Email.get(),
Telephone=telephone.get(1.0, END)))
okButton.grid(row=4)
cancelButton = Button(window, text="Cancel", command=window.destroy)
cancelButton.grid(row=4, column=1, sticky=E)
def addContactView(self):
window = Toplevel()
window.focus_set()
window.title("Add Contact")
window.resizable(width=FALSE, height=FALSE)
Label(window, text="Name ").grid(row=0, column=0)
name = Entry(window, width=30)
name.grid(row=0, column=1)
Label(window, text="Line ").grid(row=1, column=0)
line = Entry(window, width=30)
line.grid(row=1, column=1)
Label(window, text="Email ").grid(row=2, column=0)
Email = Entry(window, width=30)
Email.grid(row=2, column=1)
Label(window, text="Phone ").grid(row=3, column=0)
phone = ScrolledText(window, width=37)
phone.grid(row=3, column=1)
okButton = Button(window, text="Finish",
command=lambda: self.addContact(window, name=name.get(), line=line.get(), Email=Email.get(),
Telephone=phone.get(1.0, END)))
okButton.grid(row=4)
cancelButton = Button(window, text="Cancel", command=window.destroy)
cancelButton.grid(row=4, column=1, sticky=E)
class importCodeDialog(object):
def __init__(self, code):
root = self.root = tk.Tk()
root.resizable(0, 0)
root.title("Import Code and Packages")
self.inputCode = ScrolledText(root, height=5, width=50)
self.inputCode.insert(tk.END, code)
self.inputCode.grid(row=0, column=0, columnspan=2)
tk.Button(root, width=11, text="Save",
command=self.save_button).grid(row=1, column=0)
tk.Button(root, width=11, text="Cancel",
command=self.cancel_button).grid(row=1, column=1)
dialogTools.center(root)
def save_button(self):
self.returning = {
'code': self.inputCode.get(1.0, tk.END),
'status': 'ok'
}
self.root.quit()
def cancel_button(self):
self.returning = {'status': 'cancel'}
self.root.quit()
def main():
window = Tk()
window.title("TeamChooser")
window.geometry('600x800')
lbl = Label(window, text="Players: (name, score)")
lbl.grid(column=0, row=0)
txt = ScrolledText(window, width=25)
txt.grid(column=0, row=1, pady=10, padx=10)
txt.focus()
lbl2 = Label(window, text="Seperations:")
lbl2.grid(column=0, row=2)
txt2 = ScrolledText(window, width=25, height=10)
txt2.grid(column=0, row=3, pady=10, padx=10)
lbl3 = Label(window, text="Results")
lbl3.grid(column=1, row=0)
txt3 = ScrolledText(window, width=25)
txt3.grid(column=1, row=1, pady=10, padx=10)
btn = Button(window, text="Run Algorithm", command=lambda: calc_teams(txt.get(1.0, "end"), txt2.get(1.0, "end"), txt3))
btn.grid(column=0, row=4)
window.mainloop()
def main():
top = Tk()
labelUsername = Label(top, text="Username")
labelUsername.grid(row=0, column=0, padx=(10, 20), pady=(10, 10))
entryUsername = Entry(top, width=30)
entryUsername.grid(row=0, column=1, padx=(0, 10))
labelPassword = Label(top, text="Password")
entryPassword = Entry(top, width=30, show="*")
labelPassword.grid(row=1, column=0, padx=(10, 20), pady=(10, 10))
entryPassword.grid(row=1, column=1, padx=(0, 10))
labelMatkul = Label(
top, text="Matkul : Kelas\ncontoh:\nTKIT16022:A,\nTKIT16023:B")
labelMatkul.grid(row=2, column=0, padx=(10, 20), pady=(10, 10))
entryMatkul = ScrolledText(top, width=20, height=10)
entryMatkul.grid(row=2, column=1, padx=(0, 10), pady=(10, 10))
loginBtn = Button(
top,
text="Start KRS",
command=lambda: KRSAN(entryUsername.get(), entryPassword.get(),
getMatkulKelas(entryMatkul.get("1.0", END))))
loginBtn.grid(row=3,
columnspan=2,
sticky="nsew",
padx=(10, 10),
pady=(10, 10))
top.mainloop()
class LongTextbox(Textbox):
def config(self, **kwargs):
if 'height' in kwargs:
self.sentry.config(height=kwargs['height'])
if 'width' in kwargs:
self.sentry.config(width=kwargs['width'])
if 'text' in kwargs:
self.sentry.insert(END, kwargs['text'])
if 'lang' in kwargs:
self.lang = kwargs['lang']
self.label.config(text=self.lang[self.text])
def place(self, **kwargs):
self.parent = kwargs['parent']
self.row = kwargs['row']
self.column = kwargs['column']
self.label = Label(self.parent, text=self.lang[self.text])
self.sentry = ScrolledText(self.parent, relief=SOLID)
self.label.grid(row=self.row, column=self.column)
self.sentry.grid(row=self.row, column=self.column+1, sticky=E)
def getData(self):
return self.sentry.get('1.0', END + '-1c')
def setData(self, data):
self.sentry.delete('1.0', END)
self.config(text=data)
class Root(Tk):
def __init__(self):
super(Root, self).__init__()
self.title("IMDb genre classification")
self.minsize(480, 480)
self.parent = ttk.Frame(self)
self.buttonR()
self.text = ScrolledText(self.parent)
self.text.grid(column=0, row=2, ipady=3)
self.labelR = ttk.Label(self.parent, text="")
self.labelR.grid(column=0, row=3)
self.parent.pack(expand=1)
def buttonR(self):
self.buttonR = ttk.Button(self.parent,
text="Predict",
command=self.predict)
self.buttonR.grid(column=0, row=1)
def predict(self):
self.result = predict(self.text.get('1.0', END + '-1c'))
#self.labelR = ttk.Label(self, text = "")
#self.labelR.grid(column = 0, row = 5)
self.labelR.configure(text=self.result)
class ChatClient:
# sock = None
def __init__(self, ip, port):
self.sock = socket(AF_INET, SOCK_STREAM)
self.sock.connect((ip, port))
self.initialize_gui()
self.receiving_thread()
def initialize_gui(self):
# widget 배치 및 초기화
self.root = Tk()
fr = []
for i in range(0, 5):
fr.append(Frame(self.root))
fr[i].pack(fill=BOTH)
self.name_label = Label(fr[0], text='사용자 이름')
self.recv_label = Label(fr[1], text='수신 메시지 : ')
self.send_label = Label(fr[3], text='송신 메시지 : ')
self.send_btn = Button(fr[3], text='전송', command=self.send_chat)
self.quit_btn = Button(fr[3], text='종료', command=self.root.quit)
self.chat_transcript_area = ScrolledText(fr[2], height=20, width=60)
self.enter_text_widget = ScrolledText(fr[4], height=5, width=60)
self.name_widget = Entry(fr[0], width=15)
self.name_label.pack(side=LEFT)
self.name_widget.pack(side=LEFT)
self.recv_label.pack(side=LEFT)
self.send_btn.pack(side=RIGHT, padx=40)
self.quit_btn.pack(side=RIGHT, padx=20)
self.chat_transcript_area.pack(side=LEFT, padx=2, pady=2)
self.send_label.pack(side=LEFT)
self.enter_text_widget.pack(side=LEFT, padx=2, pady=2)
def send_chat(self):
# 메세지 전송하는 콜백함수
sender_name = self.name_widget.get().strip() + ':'
data = self.enter_text_widget.get(1.0, 'end').strip()
message = (sender_name + data).encode('utf-8')
self.chat_transcript_area.insert('end', message.decode('utf-8') + '\n')
self.chat_transcript_area.yview(END)
self.sock.send(message)
self.enter_text_widget.delete(1.0, 'end')
return 'break'
def receiving_thread(self):
# 데이터 수신 Thread 생성, 시작
t = Thread(target=self.receive_message, args=(self.sock, ))
t.start()
def receive_message(self, sock):
while True:
buf = sock.recv(256)
if not buf:
break
self.chat_transcript_area.insert('end', buf.decode('utf-8') + '\n')
self.chat_transcript_area.yview(END)
socket.close()
class Autotyper(object):
"""
Autotyper class, it generates the autotyper window, waits for entering text
and then calls a function to work with the text.
"""
def __init__(self, master, sendfunc):
"""
Initializes the autotyper.
@param master: the main tk window
@type master: Tk
@param sendfunc: the callback function
@type sendfunc: function
"""
self._sendfunc = sendfunc
self._frame = Toplevel(master)
# self._frame.geometry("400x300")
self._frame.title("Lyntin -- Autotyper")
self._frame.protocol("WM_DELETE_WINDOW", self.cancel)
if os.name == "posix":
fontname = "Courier"
else:
fontname = "Fixedsys"
fnt = tkinter.font.Font(family=fontname, size=12)
self._txt = ScrolledText(self._frame,
fg="white",
bg="black",
font=fnt,
height=20)
self._txt.pack(side=TOP, fill=BOTH, expand=1)
self._send_btn = Button(self._frame, text="Send", command=self.send)
self._send_btn.pack(side=LEFT, fill=X, expand=0)
self._cancel_btn = Button(self._frame,
text="Cancel",
command=self.cancel)
self._cancel_btn.pack(side=RIGHT, fill=X, expand=0)
def send(self):
"""
Will be called when the user clicks on the 'Send' button.
"""
text = fix_unicode(self._txt.get(1.0, END))
self._sendfunc(text)
self._frame.destroy()
def cancel(self):
"""
Will be called when the user clicks on the 'Cancel' button.
"""
self._sendfunc(None)
self._frame.destroy()
class MessageSender(tk.Frame):
"""
Component responsible for get a message from an input, encrypt it and send it
"""
def __init__(self, key: str, iv: str, progress_func, mode_chooser,
receiver_address, *args, **kwargs):
super(MessageSender, self).__init__(*args, **kwargs)
self._key = key
self._iv = iv
self._progress_func = progress_func
self._mode_chooser = mode_chooser
self._receiver_address = receiver_address
self._label = tk.Label(self, text='Write some message below')
self._text_input = ScrolledText(self, height=3)
self._button = tk.Button(self, text='send message', command=self.send)
self._pack_widgets()
def _pack_widgets(self):
self._label.pack(side=tk.TOP)
self._text_input.pack(side=tk.TOP, padx=10)
self._button.pack(side=tk.RIGHT, padx=10)
def send(self):
"""
Send written messages
"""
mode = self._mode_chooser.get_active()
host = self._receiver_address.get()
if not (self._key.key and self._iv.key):
print('Keys are not generated')
return
if host:
path = 'files/message.txt'
self._save_message_to_file(path)
message_file = File(path)
message_file.encrypt(self._key.key,
self._iv.key,
mode=mode,
progress_func=self._progress_func)
time.sleep(.1)
send_thread = SendThread(message_file,
mode=mode,
host=host,
show_progress_func=self._progress_func)
send_thread.start()
else:
print('You have to specify receiver IP address')
def _save_message_to_file(self, path):
"""
Save message data to file given by a path
"""
message = self._text_input.get('1.0', tk.END)
with open(path, 'w') as file:
file.write(message)
def set_keys(self, key, iv):
self._key = key
self._iv = iv
class LongTextbox(Textbox):
def config(self, **kwargs):
try:
self.sentry.config(height=kwargs['height'])
except:
pass
#print("the widget could not be configured")
try:
self.sentry.config(width=kwargs['width'])
except:
pass
#print("the widget could not be configured")
try:
#self.text = kwargs['text']
#self.sentry.delete(1.0, END)
self.sentry.insert(END, kwargs['text'])
except:
pass
#print("the widget could not be configured")
try:
self.lang = kwargs['lang']
self.label.config(text=self.lang[self.text])
except:
pass
def trytoplace(self, **kwargs):
self.parent = kwargs['parent']
self.row = kwargs['row']
self.column = kwargs['column']
def place(self, **kwargs):
try:
self.trytoplace(**kwargs)
except:
pass
#print("widget could not be placed")
self.label = Label(self.parent, text=self.lang[self.text])
self.sentry = ScrolledText(self.parent, relief=SOLID)
self.label.grid(row=self.row, column=self.column)
self.sentry.grid(row=self.row, column=self.column+1, sticky=E)
def getData(self):
return self.sentry.get('1.0', END + '-1c')
def setData(self, data):
self.sentry.delete('1.0', END)
self.config(text=data)
class Window5:
def __init__(self, parent, width, height, title="Генератор Рабочей программы дисциплины", resizable=(False, False),
icon=r"main.ico"):
self.root = Toplevel(parent)
self.root.title(title)
self.root.geometry(f"{width}x{height}+200+200")
self.root.resizable(resizable[0], resizable[1])
self.root.config(bg="#1f4b99")
img = PilImage.open('images/add_png.png')
img = img.resize((18, 18), PilImage.ANTIALIAS)
self.photo_image = ImageTk.PhotoImage(img)
img3 = PilImage.open('images/help_png.png')
img3 = img3.resize((18, 18), PilImage.ANTIALIAS)
self.photo_image3 = ImageTk.PhotoImage(img3)
self.root.iconbitmap('images/osu2.ico')
self.frm_form = LabelFrame(self.root, relief=SUNKEN, borderwidth=3,
text="Структура дисциплины и распределение её трудоёмкости")
self.frm_form.pack(fill=X, ipadx=30, ipady=30, padx=10)
self.text_edit = ScrolledText(self.frm_form, width=78, height=25, font=("Times New Roman", 11), wrap=WORD)
self.text_edit.grid(row=1, column=1)
self.frm_buttons = Frame(self.root)
self.frm_buttons.pack(fill=X, ipadx=5, ipady=5)
self.btn_submit = Button(self.frm_buttons, text="Добавить", image=self.photo_image, compound=LEFT,
command=self.get_text)
self.btn_submit.pack(side=LEFT, padx=10, ipadx=10)
self.btn_clear = Button(self.frm_buttons, text="Отчистить", command=self.delete_text)
self.btn_clear.pack(side=LEFT, padx=10, ipadx=10)
self.btn_help = Button(self.frm_buttons, image=self.photo_image3, command=self.help_mb)
self.btn_help.pack(side=LEFT, padx=10, ipadx=10)
def get_text(self):
text_get = self.text_edit.get("1.0", END)
doc = DocxTemplate("RPD2.docx")
context = {'mesto_discip': text_get, 'description1': "{{description1}}", 'kod_komp1': "{{kod_komp1}}",
'description2': "{{description2}}", 'kod_komp2': "{{kod_komp2}}"}
doc.render(context)
doc.save("RPD3.docx")
document = dc.Document("RPD3.docx")
full_text = []
for para in document.paragraphs:
full_text.append(para.text)
mb.showinfo("Внимание", "Титульный лист рабочей программы сформирован")
# self.mainText.insert('1.0', full_text)
def delete_text(self):
self.text_edit.delete(1.0, END)
def help_mb(self):
mb.showinfo("Помощь", "Укажите год набора, направление подготовки, профиль и наименование дисциплины. "
"Ниже показаны все добавленные вами рабочие программы")
class mainWindow:
def __init__(self, master=None):
self.master = master
self.set_app_title(None)
self.font = Font(family="Verdana", size=10)
self.text = ScrolledText(self.master,
state='normal',
height=400,
width=400,
wrap='word',
font=self.font,
pady=2,
padx=3,
undo=True,
bg='white')
self.text.pack(fill=tk.Y, expand=1)
self.text.focus_set()
self.menubar = tk.Menu(self.master, relief=tk.FLAT)
self.selectedText = None
'''configure events'''
self.events()
def build(self):
self.fileMenu = file_menu.fileMenu(self.text, self.master, self)
self.editMenu = edit_menu.editMenu(self.text, self.master, self)
self.formatMenu = format_menu.formatMenu(self.text, self.master, self)
self.helpMenu = help_menu.helpMenu(self.text, self.master, self)
def events(self):
self.text.bind("<<Selection>>", self.selected_text)
self.master.bind("<Button-1>", self.mouse_click)
self.menubar.bind("<Button-1>", self.mouse_click)
def set_app_title(self, file_name):
app_title = my_globals.BTTE_NAME() + '-'
app_title += 'v' + my_globals.BTTE_VERSION() + '-'
if not file_name:
file_name = "Untitled"
app_title += file_name
self.master.title(app_title)
'''EVENTS'''
def selected_text(self, event):
oldSelectedText = self.selectedText
try:
self.selectedText = self.text.get(tk.SEL_FIRST, tk.SEL_LAST)
except:
self.selectedText = None
''' update edit menu'''
if oldSelectedText != self.selectedText:
self.editMenu.update()
def mouse_click(self, event):
self.editMenu.rightClick.unpost()
class ConsoleUi:
"""Poll messages from a logging queue and display them in a scrolled text widget"""
def __init__(self, frame):
self.frame = frame
self.input_start_idx = tk.END
# Create a ScrolledText wdiget
self.scrolled_text = ScrolledText(frame, state='disabled', height=12)
self.scrolled_text.pack(expand=True, fill=tk.BOTH)
self.scrolled_text.configure(font='TkFixedFont')
self.scrolled_text.tag_config('INFO', foreground='black')
self.scrolled_text.tag_config('DEBUG', foreground='gray')
self.scrolled_text.tag_config('WARNING', foreground='dark orange')
self.scrolled_text.tag_config('ERROR', foreground='red')
self.scrolled_text.tag_config('CRITICAL', foreground='red', underline=1)
self.scrolled_text.bind('<Key>', self.key_press)
# Create a logging handler using a queue
self.log_queue = queue.Queue()
self.queue_handler = QueueHandler(self.log_queue)
formatter = logging.Formatter('%(asctime)s:\t%(message)s', datefmt='%H:%M:%S')
self.queue_handler.setFormatter(formatter)
logger.addHandler(self.queue_handler)
# Start polling messages from the queue
self.frame.after(100, self.poll_log_queue)
def display(self, record):
msg = record.getMessage()
self.scrolled_text.configure(state='normal')
self.scrolled_text.insert(tk.END, msg + '\n', record.levelname)
# self.scrolled_text.configure(state='disabled')
# Autoscroll to the bottom
self.scrolled_text.yview(tk.END)
self.scrolled_text.mark_set('input_start', 'end-1c')
self.scrolled_text.mark_gravity('input_start', tk.LEFT)
def poll_log_queue(self):
while True:
try:
record = self.log_queue.get(block=False)
except queue.Empty:
break
else:
self.display(record)
# Check every 100ms if there is a new message in the queue to display
self.frame.after(100, self.poll_log_queue)
def key_press(self, event):
"""Function used to send any inputs to the input_queue when the return key is pressed"""
if event.char == '\r':
user_input = self.scrolled_text.get('input_start', 'end-1c').strip()
input_queue.put(user_input)
self.scrolled_text.mark_set('input_start', 'end-1c')
class LongTextbox(Textbox):
def config(self, **kwargs):
try:
self.sentry.config(height=kwargs['height'])
except:
pass
#print("the widget could not be configured")
try:
self.sentry.config(width=kwargs['width'])
except:
pass
#print("the widget could not be configured")
try:
#self.text = kwargs['text']
#self.sentry.delete(1.0, END)
self.sentry.insert(END, kwargs['text'])
except:
pass
#print("the widget could not be configured")
try:
self.lang = kwargs['lang']
self.label.config(text=self.lang[self.text])
except:
pass
def trytoplace(self, **kwargs):
self.parent = kwargs['parent']
self.row = kwargs['row']
self.column = kwargs['column']
def place(self, **kwargs):
try:
self.trytoplace(**kwargs)
except:
pass
#print("widget could not be placed")
self.label = Label(self.parent, text=self.lang[self.text])
self.sentry = ScrolledText(self.parent, relief=SOLID)
self.label.grid(row=self.row, column=self.column)
self.sentry.grid(row=self.row, column=self.column + 1, sticky=E)
def getData(self):
return self.sentry.get('1.0', END + '-1c')
def setData(self, data):
self.sentry.delete('1.0', END)
self.config(text=data)
class TextField:
def __init__(self, master):
self.master = master
self.textField = ScrolledText(self.master,
width=50,
height=30,
font=20)
self.textField.pack()
def printText(self):
print(self.textField.get('1.0', 'end-1c'))
class HMDmain(tk.Frame):
def __init__(self, parent, *args, **kwargs):
tk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
self.parent.option_add('*tearOff', False)
self.after(50, self.onAfter)
#set this frame to expand to %100 available space
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
#init menu
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = Menu(menubar)
fileMenu.add_command(label="Save", command=self.onSave)
fileMenu.add_command(label="Load", command=self.onLoad)
fileMenu.add_command(label="Exit", command=self.onExit)
menubar.add_cascade(label="File", menu=fileMenu)
#init textbox
self.text = ScrolledText(self, wrap='word')
#add widgets to the layout manager
self.text.grid(sticky=inflate)
def onExit(self):
self.quit()
def onSave(self):
darkIO.DarkIO.save(asksaveasfilename(), self.text.get(0.0, 'end'))
def onLoad(self):
if not askyesno(
"Clear All Text",
"Loading a new file will clear the current project \n"
"Would you like to continue?"):
return
loadText = ""
try:
fname = askopenfile()
loadText = darkIO.DarkIO.load(fname.name)
except UnicodeDecodeError:
showerror("Invalid File Type", "Unable to read file.")
else:
self.text.delete(0.0, 'end')
self.text.insert(0.0, loadText)
def onAfter(self):
print("Working")
self.after(30000, self.onAfter)
class EditMemory(Dialog):
def __init__(self, parent, memory, state):
self.memory = memory
self.state = state
self.inheritability = tk.StringVar()
self.delete_button = None
self.memory_textbox = None
Dialog.__init__(self,
parent,
title="Edit memory entry",
enter_to_apply=False)
def body(self, master):
self.memory_textbox = ScrolledText(master, height=3)
self.memory_textbox.grid(row=master.grid_size()[1],
column=0,
columnspan=2)
self.memory_textbox.configure(
font=Font(
family="Georgia",
size=12), # Other nice options: Helvetica, Arial, Georgia
spacing1=10,
foreground=text_color(),
background=bg_color(),
padx=3,
pady=3,
spacing2=3, # Spacing between lines
spacing3=5,
wrap="word",
)
self.memory_textbox.insert(tk.INSERT, self.memory['text'])
self.memory_textbox.focus()
row = master.grid_size()[1]
create_side_label(master, "Inheritability", row)
inheritability_options = ('none', 'subtree', 'delayed')
self.inheritability.set(self.memory['inheritability'])
dropdown = tk.OptionMenu(master, self.inheritability,
*inheritability_options)
dropdown.grid(row=row, column=1, pady=3)
self.delete_button = create_button(master,
"Delete memory",
self.delete_memory,
width=15)
def delete_memory(self):
self.state.delete_memory_entry(self.memory)
self.cancel()
def apply(self):
memory_text = self.memory_textbox.get("1.0", 'end-1c')
self.memory['text'] = memory_text
self.memory['inheritability'] = self.inheritability.get()
class ViewPaster():
"""Paste window"""
def __init__(self, parent):
self.parent = parent
windowtitle = tk.Label(parent,
text="Month heatmap",
font=("Helvetica", 12, "bold"))
windowtitle.pack(fill=tk.X)
fr1 = tk.Frame(parent)
fr1.pack(anchor=tk.W)
welcome = tk.Message(fr1,
bg="white",
text="Paste list:month[tabulation]value",
width=1000)
welcome.pack(anchor=tk.W)
self.data_list = ScrolledText(fr1)
self.data_list.pack(fill=tk.X)
fr2 = tk.Frame(parent)
fr2.pack(anchor=tk.W, fill=tk.X)
bn_paste = tk.Button(fr2, text="Paste", command=self.paste_list)
bn_paste.pack(side=tk.LEFT)
bn_reset = tk.Button(fr2, text="Reset", command=self.reset)
bn_reset.pack(side=tk.LEFT)
bn_process = tk.Button(fr2, text="Draw heatmap", command=self.process)
bn_process.pack(side=tk.LEFT)
def paste_list(self):
self.reset()
self.data_list.insert("end", self.data_list.clipboard_get())
def reset(self):
self.data_list.delete(1.0, "end")
def process(self):
data = self.data_list.get(1.0, "end")
if (data != "\n"):
filename = filedialog.asksaveasfilename(\
title="Save as",
initialdir="C:\corpus",
initialfile="MonthHeatmap.svg",
filetypes = [("svg Files","*.svg")])
values = parse_data(data)
svg = create_svg(values)
with open(filename, 'wb') as pointer:
pointer.write(svg.encode('utf-8'))
webbrowser.open(filename, 0, 1)
class PopOutWindow:
"""Pop out window which is used to snap multiple tab contents"""
def __init__(self, parent):
self.parent = parent
self.top = tk.Toplevel(parent.master)
self.top.title('Pop Out')
self.editor = None
self.toolbar = None
self.create_widgets()
def create_widgets(self):
self.toolbar = tk.Frame(self.top, bg="#eee")
self.toolbar.pack(side="top", fill="x")
self.catch_btn = ttk.Button(self.toolbar,
text='Catch',
command=self.catch_data,
style='bb.TButton')
self.catch_btn.pack(side="left", pady=(2, 2), padx=(2, 1))
self.dock_btn = ttk.Button(self.toolbar,
text='Dock',
command=self.dock_window,
style='bb.TButton')
self.dock_btn.pack(side="left", pady=(2, 2), padx=(1, 2))
# Horizontal scrollbar
horizontal_scrollbar = tk.Scrollbar(self.top, orient=tk.HORIZONTAL)
horizontal_scrollbar.pack(side="top", fill="x")
self.editor = ScrolledText(self.top, width=60, height=20)
self.editor.pack(fill="both", expand=True)
self.editor['wrap'] = tk.NONE
self.editor['background'] = '#FEFCD7'
self.editor['foreground'] = 'blue'
# Set target text box to horizontal scrollbar
horizontal_scrollbar["command"] = self.editor.xview
self.editor['xscrollcommand'] = horizontal_scrollbar.set
def catch_data(self):
caught_data = self.parent.selected_data()
if caught_data is not None:
self.editor.insert(tk.END, caught_data)
def dock_window(self):
dockable_data = self.editor.get("1.0", 'end-1c')
if dockable_data is not None and dockable_data != '':
self.parent.dock_popup(dockable_data)
self.top.destroy()
class AskRule(tkDialog.Dialog):
def __init__(self, parent, anterior):
top = tkDialog.Dialog.__init__(self, parent, "Enter naming rule",
anterior)
self.text = None
def body(self, master):
self.text = ScrolledText(master, width=60, height=10)
self.text.grid(sticky=N + W + E + S)
self.text.insert(END, self.other)
self.result = None
def apply(self):
self.result = self.text.get(1.0, END)
class MainWindow:
def __init__(self, root):
self.root = root
self.root.title("Valider les Sms")
self.label1 = ScrolledText(self.root)
self.label1.grid(row=0, columnspan=3, sticky='NSEW')
self.ButtonClear = tk.Button(self.root,
text='Nettoyer',
command=self.clear_message)
self.ButtonClear.grid(column=0, row=1, sticky='NSEW')
self.ButtonValidate = tk.Button(self.root,
text='Valider',
command=self.validate_message)
self.ButtonValidate.grid(column=1, row=1, sticky='NSEW')
self.ButtonMessageupdade = tk.Button(self.root,
text='Mettre à jour',
command=self.give_new_message)
self.ButtonMessageupdade.grid(column=2, row=1, sticky='NSEW')
self.current_message = ""
self.give_new_message()
self.updater()
def clear_message(self):
self.label1.delete(1.0, tk.END)
file = open('sms_reçu.txt', "r+")
lines = file.readlines()
file.seek(0)
for line in lines[1:]:
file.write(line)
file.truncate()
file.close()
self.give_new_message()
def validate_message(self):
path = 'sms_' + time.strftime("%Y-%m-%d_%I_%M_%S") + '.json'
with open('sms_valides/' + path, 'w') as json_file:
json.dump(self.label1.get(1.0, tk.END), json_file)
self.clear_message()
def give_new_message(self):
if self.label1.compare("end-1c", "==", "1.0"):
with open('sms_reçu.txt', 'r') as file:
line = file.readline()
if line != '':
self.current_message = re.split(r"<br>", line)[1]
self.label1.insert(tk.INSERT, self.current_message)
def updater(self):
self.give_new_message()
self.root.after(5000, self.updater)
class Multiline_textbox(Textbox):
def __init__(self, parent_frame, x, y):
Widget_.__init__(self, parent_frame, x, y)
self.entry.pack_forget()
self.entry = ScrolledText(self.widget_frame, width=self.entry_width)
self.entry.pack(side=LEFT)
def get_info(self):
return self.label.cget('text'), self.entry.get('1.0', END + '-1c')
def set_text_field(self, label=False, entry=False):
if label:
self.label.config(text=label)
if entry:
self.entry.delete('1.0', END)
self.entry.insert('1.0', entry)
class TextInputer:
def __init__(self, root):
self.enter_widget = ScrolledText(root, height=1)
def pack(self, *args, **kwargs):
self.enter_widget.pack(*args, **kwargs)
@property
def text(self):
return self.enter_widget.get('1.0', END)[:-1]
@text.setter
def text(self, new_text):
self.enter_widget.delete('1.0', END)
self.enter_widget.insert('1.0', new_text)
def __init__(self, master):
Frame.__init__(self, master,bg='lightblue')
Frame.configure(self)
user = self.master.user_entry
receiver = self.master.target
print(receiver) #for debugging
mycursor.execute(f" select * from chatbox where ( (sender = \'{user}\' and receiver = \'{receiver}\' ) or (sender = \'{receiver}\' and receiver = \'{user}\' ))")
result = mycursor.fetchall()
print(result) #for debugging
if result is not None:
for (message,i) in zip(result, range(len(result)) ):
Label(self, text=f"{message[1]} : ", fg="green", bg='lightblue').grid(row=i, column=0, pady=3)
Label(self, text=f"{message[3]} ", bg='lightblue').grid(row=i, column=1, pady=3)
st = ScrolledText(self, width=50, height=2)
st.grid(row=1000, column=0)
Button(self, text="send", command= lambda : self.send(user, receiver, st.get(0.0, END))).grid(row=1000, column=1)
class AnswerTextFrame(tk.LabelFrame):
def __init__(self, master, **option):
option.setdefault('text', '答え（改行区切り）')
super().__init__(master, **option)
self.answerText = ScrolledText(self, height=5, undo=True)
self.answerText.pack()
@property
def answer(self):
answerStr = self.answerText.get('1.0', tk.END).strip()
answerList = answerStr.split('\n')
return [ans.strip() for ans in answerList if ans.strip()]
@answer.setter
def answer(self, answerStr):
self.answerText.delete('1.0', tk.END)
self.answerText.insert(tk.END, answerStr.strip())
class QueryWindow(Window):
def __init__(self, connection, cursor, font_style):
super().__init__(connection, cursor, font_style)
self.window.wm_title('Query Interface')
self.window.geometry('800x600')
# Query field
self.query_label = tk.Label(self.window,
text='Query',
font=self.font_style)
self.query_label.place(x=20, y=120, height=100, width=100)
self.query_label.config(background='gray80')
self.query_entry = ScrolledText(self.window)
self.query_entry.place(x=120, y=120, height=100, width=660)
# Query status
self.status_label = tk.Label(self.window,
text='',
font=self.font_style)
self.status_label.configure(background='white')
self.status_label.place(x=20, y=270, height=30, width=760)
# Decide the position
# Result field
self.result.place(x=20, y=320, width=760)
self.listBox.place(x=20, y=350, height=200, width=760)
self.yscroll.place(x=780, y=350, height=180)
self.xscroll.place(x=20, y=550, width=760)
# Query button
self.query_button.place(x=720, y=60, height=30, width=60)
def send_query(self):
try:
# Setting the query
self.query = self.query_entry.get('1.0', tk.END)
# Send select statement
self.display_result(self.query)
self.connection.commit()
self.status_label.configure(text='Query Success')
self.status_label.configure(background='chartreuse3', fg='white')
except:
self.status_label.configure(text='Query Failed')
self.status_label.configure(background='orange red', fg='white')
def clean_value(self):
self.query_entry.delete('1.0', tk.END)
class MyClipboardFunc(Toplevel):
global cp_list
def __init__(self, parent=None):
Toplevel.__init__(self, parent)
self.frm = Frame(self)
self.frm.pack()
self.scrltxt = ScrolledText(self.frm, width=50, height=15)
self.scrltxt.pack(side=TOP, fill=BOTH, expand=YES)
btn_add = Button(self.frm, text='Add', command=self.onAdd)
btn_add.pack(side=BOTTOM, anchor=NW)
btn_back = Button(self.frm, text='Back', command=self.onBack)
btn_back.pack(side=BOTTOM, anchor=NE)
def onAdd(self):
text = self.scrltxt.get(SEL_FIRST, SEL_LAST)
seq = len(cp_list)
if not text in cp_list:
cp_list.append((seq, text))
def onBack(self):
print(cp_list)
self.destroy()
class SendMailWindow:
def __init__(self, sender_mail, recipient_mail, pwd):
'''
create the add friend window.
'''
self.root = tk.Tk()
self.root.title('Send email to '+recipient_mail)
self.sender_mail = sender_mail
self.recipient_mail = recipient_mail
self.password = pwd
self.pane_for_recipient = tk.PanedWindow(self.root,orient=tk.HORIZONTAL, borderwidth=5)
self.pane_for_recipient.pack(fill=tk.BOTH)
self.lable_for_recipient = tk.Label(self.pane_for_recipient, text='To:', width=5, justify=tk.LEFT, anchor=tk.W)
self.entry_for_recipient = tk.Entry(self.pane_for_recipient, width=10)
self.entry_for_recipient.insert(0, recipient_mail)
self.pane_for_recipient.add(self.lable_for_recipient)
self.pane_for_recipient.add(self.entry_for_recipient)
self.pane_for_topic = tk.PanedWindow(self.root, orient=tk.HORIZONTAL, borderwidth=5)
self.pane_for_topic.pack(fill=tk.BOTH)
self.lable_for_topic = tk.Label(self.pane_for_topic, text='Topic:', width=5, justify=tk.LEFT, anchor=tk.W)
self.entry_for_topic = tk.Entry(self.pane_for_topic, width=10)
self.pane_for_topic.add(self.lable_for_topic)
self.pane_for_topic.add(self.entry_for_topic)
self.pane_for_content = tk.PanedWindow(self.root, orient=HORIZONTAL, borderwidth=7)
self.pane_for_content.pack(fill=tk.BOTH, expand=1)
self.lable_for_content = tk.Label(self.pane_for_content, text='Text:', justify=tk.LEFT, anchor=tk.W)
self.text_for_content = ScrolledText(self.pane_for_content, width=10, height=4)
self.pane_for_content.add(self.lable_for_content)
self.pane_for_content.add(self.text_for_content)
self.pane_for_button = tk.PanedWindow(self.root, orient=tk.HORIZONTAL)
self.pane_for_button.pack(fill=tk.BOTH)
self.button_for_add = tk.Button(self.pane_for_button, text="Send", command=self.SendMail)
self.button_for_close = tk.Button(self.pane_for_button, text="Exit", command=self.Destroy, width=5)
self.pane_for_button.add(self.button_for_close)
self.pane_for_button.add(self.button_for_add)
self.root.geometry('300x200')
def SendMail(self):
sender = self.sender_mail
password = self.password
recipient_email = self.entry_for_recipient.get()
topic = self.entry_for_topic.get()
text = self.text_for_content.get(1.0, tk.END)
'''call www's function here'''
myEmail = mh.Email(sender, password)
if myEmail.login():
myEmail.sendMailSmtp(recipient_email, topic, text)
'''close after send'''
self.Destroy()
print('Sender: ',sender, '\nTo: ', recipient_email, '\nTopic: ', topic)
print('Text: \n', text)
def Destroy(self):
self.root.destroy()
class BatchRenameApp(Frame):
"""Batch renaming app"""
def __init__(self, parent=None):
self.parent=parent
if not self.parent:
Frame.__init__(self)
self.main=self.master
else:
self.main=Toplevel()
self.master=self.main
self.main.title('Batch Rename')
ws = self.main.winfo_screenwidth()
hs = self.main.winfo_screenheight()
w = 800; h=500
x = (ws/2)-(w/2); y = (hs/2)-(h/2)
self.main.geometry('%dx%d+%d+%d' % (w,h,x,y))
self.doGUI()
self.currentdir = os.path.expanduser('~')
return
def doGUI(self):
"""Create GUI"""
self.m = PanedWindow(self.main,
orient=HORIZONTAL)
self.m.pack(side=LEFT,fill=BOTH,expand=1)
self.fileslist = ScrolledText(self.m, width=50, height=20)
self.m.add(self.fileslist)
self.preview = ScrolledText(self.m, width=20, height=20)
self.m.add(self.preview)
fr=Frame(self.main, padding=(4,4), width=90)
b=Button(fr,text='Add Folder',command=self.addFolder)
b.pack(side=TOP,fill=BOTH,pady=2)
b=Button(fr,text='Clear',command=self.clear)
b.pack(side=TOP,fill=BOTH,pady=2)
self.patternvar = StringVar()
self.patternvar.set('*.*')
self.filepattern = Entry(fr, textvariable=self.patternvar)
Label(fr,text='Wildcard:').pack(side=TOP)
self.filepattern.pack(side=TOP,fill=BOTH,pady=2)
self.findvar = StringVar()
self.findvar.set(' ')
self.findtext = Entry(fr, textvariable=self.findvar)
Label(fr,text='Find:').pack(side=TOP)
self.findtext.pack(side=TOP,fill=BOTH,pady=2)
self.replacevar = StringVar()
self.replacevar.set('.')
self.replacetext = Entry(fr, textvariable=self.replacevar)
Label(fr,text='Replace With:').pack(side=TOP)
self.replacetext.pack(side=TOP,fill=BOTH,pady=2)
b=Button(fr,text='Preview',command=self.dopreview)
b.pack(side=TOP,fill=BOTH,pady=2)
b=Button(fr,text='Execute',command=self.execute)
b.pack(side=TOP,fill=BOTH,pady=2)
fr.pack(side=LEFT,fill=BOTH)
return
def addFolder(self,path=None):
"""Get a folder"""
if path==None:
path = filedialog.askdirectory(parent=self.main,
initialdir=self.currentdir,
title='Select folder')
if path:
self.path = path
#self.refresh()
self.dopreview()
self.currentdir = path
return
def refresh(self):
"""Load files list"""
self.fileslist.delete('1.0',END)
fp = self.patternvar.get()
flist = glob.glob(os.path.join(self.path,fp))
filestr = '\n'.join(flist)
self.fileslist.insert(END, filestr)
return
def dopreview(self):
"""Preview update"""
self.refresh()
self.preview.delete('1.0',END)
flist = self.fileslist.get('1.0',END)
flist = flist.split('\n')
find = self.findvar.get()
repl = self.replacevar.get()
new = doFindReplace(files=flist, find=find, replace=repl)
new = '\n'.join(new)
self.preview.insert(END,new)
return
def clear(self):
self.fileslist.delete('1.0',END)
self.preview.delete('1.0',END)
self.path = None
return
def execute(self):
"""Do rename"""
n = messagebox.askyesno("Rename",
"Rename the files?",
parent=self.master)
if not n:
return
flist = self.fileslist.get('1.0',END).split('\n')
find = self.findvar.get()
repl = self.replacevar.get()
doFindReplace(files=flist, find=find, replace=repl, rename=True)
self.refresh()
return
class SpinDelight(Frame):
def __init__(self):
Frame.__init__(self)
self.master.geometry("1020x600+150+50")
self.master.title("Spin Delight 1.0 - Copyright (c) Robin Thomas")
self.master.resizable(0,0)
self.grid()
self.brwe = Button(self, text = "Browse", command = self.open_file, width = 10, relief = "groove")
self.rtxt = Label(self, text="Input Text:")
self.txt1 = ScrolledText(self, width = 50, height = 25)
self.txt1.bind("<Control-Key-a>", self.select_all_txt1)
self.txt1.bind("<Control-Key-A>", self.select_all_txt1)
self.spin = Button(self, text = "Spin", command = self.spin_file, width = 10, relief = "groove")
self.stxt = Label(self, text="Spun Text:")
self.txt2 = ScrolledText(self, width = 50, height = 25)
self.txt2.bind("<Control-Key-a>", self.select_all_txt2)
self.txt2.bind("<Control-Key-A>", self.select_all_txt2)
self.brwe.grid(row = 2, column = 2, pady = 15)
self.rtxt.grid(row = 2, column = 0, padx = 25)
self.txt1.grid(row = 3, column = 0, columnspan = 10, padx = 25)
self.spin.grid(row = 3, column = 12)
self.stxt.grid(row = 2, column = 13, padx = 25, pady = 5)
self.txt2.grid(row = 3, column = 13, columnspan = 10, padx = 25)
def select_all_txt1(self,event):
self.txt1.tag_add(SEL, "1.0", END)
self.txt1.mark_set(INSERT, "1.0")
self.txt1.see(INSERT)
return 'break'
def select_all_txt2(self,event):
self.txt2.tag_add(SEL, "1.0", END)
self.txt2.mark_set(INSERT, "1.0")
self.txt2.see(INSERT)
return 'break'
def open_file(self):
fname = askopenfilename(filetypes=(("Text files", "*.txt"), ("All files", "*.*") ))
if fname:
try:
self.txt1.delete(0.0, END)
f = open(fname,'r')
self.txt1.insert(INSERT,f.read())
except:
showerror("Open Source File", "Failed to read file\n'%s'" % fname)
def spin_file(self):
txt = self.txt1.get("1.0", END)
self.txt2.delete(0.0, END)
if len(txt):
try:
words = sub(r'([.,?])+', r' \1 ', sub(r'[^a-zA-Z0-9 .,?]+', ' ', txt)).split()
w1 = words[0]
z = [(words[j - 1], words[j]) for j in range(1, len(words))]
values = self.generate_dict(z, w1)
string = self.generate_sent(values)
if len(string):
self.txt2.insert(INSERT, string)
else:
showerror("Error", "Insufficient data to spin !!")
except:
showerror("Error", "Nothing to spin !!")
def generate_dict(self, x, w1):
values = {'.': [w1]}
for (wa, wb) in x:
if wa in values:
values[wa].append(wb)
else:
values[wa] = [wb]
return values
def generate_sent(self, values):
w1 = '.'
w2 = choice(values[w1])
string = w2
values[w1].remove(w2)
while values:
w1 = w2
if len(values[w1]):
w2 = choice(values[w1])
else:
del values[w1]
w1 = '.'
break
if w2 in ('.', ',', '?'):
string += w2
else:
string += " " + w2
values[w1].remove(w2)
return string
class Frame(Tk.Frame):
def __init__(self, master=None):
global start_flag
Tk.Frame.__init__(self, master)
self.gw = Gateway()
#### COMMAND DISPLAY
self.panid= Tk.IntVar()
self.panid=0xABCD
self.PanidDisp= Tk.StringVar()
self.PanidDisp.set(hex(self.panid))
self.master.title('Lazurite Gateway')
self.row_offset = 0
# DISPLAY LOGO
# f_command = Tk.Frame(self, relief=Tk.RIDGE, bd=4)
f_command = Tk.Frame(self, bd=4)
self.image= Tk.PhotoImage(file=LOGO)
self.logoBackGround=Tk.Label(f_command, image=self.image, bg='gray', relief=Tk.RIDGE, anchor=Tk.W)
f_cb = Tk.Frame(self,bd=4)
# DISPLAY Channel
self.ch =33
self.chNumberDisp = Tk.IntVar()
self.chNumberDisp.set(self.ch)
self.l_ch = Tk.Label(f_command,text="Ch", relief=Tk.RIDGE, anchor=Tk.W)
self.t_ch = Tk.Entry(f_command,textvariable=self.chNumberDisp,width=10, relief=Tk.SUNKEN, bd=2, state=Tk.NORMAL)
self.b_chIncButton = Tk.Button(f_command, font=('Helvetica', '6'), text='+', command=self.chInc)
self.b_chDecButton = Tk.Button(f_command, font=('Helvetica', '6'), text='-', command=self.chDec)
# DISPLAY Power
self.pwr = (1,20)
self.l_pwr = Tk.Label(f_command,text="Pwr", relief=Tk.RIDGE, anchor=Tk.W)
self.b_pwr = zz.Combobox(f_command,value=self.pwr, width=10,state="readonly")
self.b_pwr.current(1)
# DISPLAY Rate
self.rate = (50,100)
self.l_rate = Tk.Label(f_command,text="Rate", relief=Tk.RIDGE, anchor=Tk.W)
self.b_rate = zz.Combobox(f_command,value=self.rate, width=10,state="readonly")
self.b_rate.current(1)
# DISPLAY PANID
self.l_panid = Tk.Label(f_command,text="PANID", relief=Tk.RIDGE, anchor=Tk.W)
self.t_panid = Tk.Entry(f_command,textvariable=self.PanidDisp,width=10, relief=Tk.SUNKEN, bd=2, state=Tk.NORMAL)
# DISPLAY Start/Stop Button
self.b_start = Tk.Button(f_command, text='Start', command=self.Start)
self.b_stop = Tk.Button(f_command, text='Stop', command=self.Stop, state=Tk.DISABLED)
## Option check buttom
self.ign = Tk.BooleanVar()
self.c_ign = Tk.Checkbutton(f_command,text="Ignore address",variable=self.ign)
# DISPLAY display mode
global mac_menu
global mac_combobox
global mac_mode
mac_combobox=zz.Combobox(f_command,value=mac_menu,width=20,state="readonly")
mac_combobox.current(mac_mode)
## InfoCorpus
# self.InfoCorpus= Tk.PhotoImage(file='InfoCorpusLogo.gif')
# self.ImageInforcopus = Tk.Label(f_command, image=self.InfoCorpus, bg='gray', relief=Tk.RIDGE)
# DISPLAY save log buttom
self.b_savelog=Tk.Button(f_command, text='SAVE', command=self.Save, state=Tk.NORMAL)
self.b_clearlog=Tk.Button(f_command, text='CLEAR LOG', command=self.Clear, state=Tk.NORMAL)
self.b_view=Tk.Button(f_command, text='VIEW', command=self.View, state=Tk.NORMAL)
## Command Frame Location
self.logoBackGround.grid(row=0,column=0)
self.b_start.grid(row=0, column=4)
self.b_stop.grid(row=0, column=5)
self.l_ch.grid(row=2,column=0,sticky=Tk.W + Tk.E,pady=10)
self.t_ch.grid(row=2,column=1,padx=20,sticky=Tk.W)
self.b_chIncButton.grid(row=2, column=4, sticky=Tk.W + Tk.E + Tk.S)
self.b_chDecButton.grid(row=2, column=5, sticky=Tk.W + Tk.E + Tk.S)
self.l_pwr.grid(row=4,column=0,sticky=Tk.W + Tk.E,pady=10)
self.b_pwr.grid(row=4,column=1,padx=20,sticky=Tk.W)
self.l_rate.grid(row=5,column=0,sticky=Tk.W + Tk.E,pady=10)
self.b_rate.grid(row=5,column=1,padx=20,sticky=Tk.W)
self.l_panid.grid(row=6,column=0,sticky=Tk.W + Tk.E,pady=10)
self.t_panid.grid(row=6,column=1,padx=20,sticky=Tk.W)
self.c_ign.grid(row=0,column=6,sticky=Tk.W + Tk.E,padx=20)
mac_combobox.grid(row=5,column=6,padx=20)
self.b_savelog.grid(row=6,column=6,padx=20)
self.b_clearlog.grid(row=6,column=7,padx=20)
self.b_view.grid(row=6,column=8,padx=20)
# self.ImageInforcopus.grid(row=0, column=8)
## LOG WINDOW
global XSCALL
global YSCALL
f_log = Tk.Frame(self)
# self.logText = Tk.StringVar()
# self.logText.set("")
self.s_logtext=ScrolledText(f_log,width=XSCALL, height=YSCALL)
self.s_logtext.grid(sticky=Tk.W+Tk.E)
self.s_logtext.write = self.write
sys.stdout = self.s_logtext
## FRAME Location
f_command.pack()
f_log.pack()
def write(self,str):
self.s_logtext.insert(Tk.END,str)
time.sleep(0.001)
self.s_logtext.yview_scroll(str.count("\n") + 1, "units")
def Start(self):
global start_flag
## update parameters
self.ch = self.chNumberDisp.get()
self.pwr = int(self.b_pwr.get())
self.rate = int(self.b_rate.get())
self.panid = int(self.PanidDisp.get(),0)
## parameter check
if self.ch < 24 or self.ch > 61:
print("ch number error")
return
if self.pwr != 1 and self.pwr != 20:
print("power error =",self.pwr)
return
if self.rate != 50 and self.rate != 100:
print("rate error=",self.rate)
return
if self.panid <= 0 or self.panid > 0xffff:
print("PANID error")
return
## Start Gateway
self.b_start.configure(state=Tk.DISABLED)
self.b_stop.configure(state=Tk.NORMAL)
self.b_chIncButton.configure(state=Tk.DISABLED)
self.b_chIncButton.configure(state=Tk.DISABLED)
self.logoBackGround.configure(bg=BLUE)
self.b_savelog.configure(state=Tk.DISABLED)
start_flag = True
self.init_gateway()
def Stop(self):
global start_flag
self.b_start.configure(state=Tk.NORMAL)
self.b_stop.configure(state=Tk.DISABLED)
self.b_chIncButton.configure(state=Tk.NORMAL)
self.b_chIncButton.configure(state=Tk.NORMAL)
self.logoBackGround.configure(bg='gray')
self.b_savelog.configure(state=Tk.NORMAL)
start_flag = False
self.gw.close_driver()
self.gw.remove_driver()
def chInc(self):
self.ch = self.chNumberDisp.get()
if self.ch < 61 and self.ch >= 24:
self.ch += 1
elif self.ch < 24:
self.ch = 24
else:
self.ch = 61
self.chSet()
def chDec(self):
self.ch = self.chNumberDisp.get()
if self.ch <= 61 and self.ch > 24:
self.ch -= 1
elif self.ch > 61:
self.ch = 61
else:
self.ch = 24
self.chSet()
def chSet(self):
self.chNumberDisp.set(self.ch)
def Clear(self):
self.s_logtext.delete(1.0,Tk.END)
def Save(self):
filename = Tk.filedialog.asksaveasfile(filetypes = [('Log Files', ('.log'))])
if filename != "":
logfile = open(filename.name,mode = 'w')
log_data = self.s_logtext.get(1.0,Tk.END)
logfile.write(log_data)
logfile.close()
return
def View(self):
print ("GADGADGADGADGA")
view_file = open("/home/pi/python/camera.jpeg",mode = 'rb')
# for i in range(1,1000):
# print (view_file.read())
def init_gateway(self):
if self.ign.get():
self.mode = 1
else:
self.mode = 0
self.gw.load_driver(self.ch,self.pwr,self.rate,self.panid,self.mode)
self.gw.open_driver()
def close(self):
if self.dvice_open:
self.gw.close_driver()
self.gw.remove_driver()
class App(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
self.bmm = BMMSegment(4)
self.mp = MaxProbabilitySegment()
self.tagger = HMM_Viterbi_POS_TAGGER()
self.parser = TopDownParser()
self.cykParser = CYKParser()
def initUI(self):
self.parent.title("双向最大匹配分词")
self.pack(fill=BOTH, expand=1)
self.columnconfigure(0, weight=3)
self.columnconfigure(1, weight=3)
self.columnconfigure(2, pad=7)
self.rowconfigure(1, weight=3)
self.rowconfigure(5, weight=3)
self.menubar = Menu(self.parent)
self.fileMenu = Menu(self.menubar, tearoff=0)
self.fileMenu.add_command(label="读入规则文件", command=self.onLoadRules_CYK)
self.fileMenu.add_separator()
self.fileMenu.add_command(label="退出", command=self.parent.quit)
self.menubar.add_cascade(label="文件", menu=self.fileMenu)
self.parent.config(menu=self.menubar)
self.label1 = Label(self, text="请输入PCFG语法规则或加载规则文件(如：S -> NP VP 0.1)")
self.label1.grid(sticky=W, pady=4, padx=5)
self.inputText = ScrolledText(self)
self.inputText.grid(row=1, column=0, columnspan=2, rowspan=3,
padx=5, sticky=E+W+N)
self.inputText.tag_config('highlight', background='yellow')
self.label2 = Label(self, text='请输入文本：')
self.label2.grid(row=4, column=0, sticky=W, pady=4, padx=5)
self.outputText = ScrolledText(self)
self.outputText.grid(row=5, column=0, columnspan=2, rowspan=3,
padx=5, sticky=E+S+W)
self.rightFrame = Frame(self)
self.rightFrame.grid(row=1, column=3, rowspan=7)
self.bmmBtn = Button(self.rightFrame, text="双向最大匹配", command=self.onBMM)
self.bmmBtn.pack(side="top", expand=True, pady=8)
self.mpBtn = Button(self.rightFrame, text="最大概率分词", command=self.onMP)
self.mpBtn.pack(side="top", expand=True, pady=8)
self.hmmBtn = Button(self.rightFrame, text='HMM词性标注', command=self.onHMM)
self.hmmBtn.pack(side="top", expand=True, pady=8)
self.parseBtn = Button(self.rightFrame, text='语法分析', command=self.onTopdownParse)
self.parseBtn.pack(side="top", expand=True, pady=8)
self.cykBtn = Button(self.rightFrame, text='PCFG语法分析', command=self.onCYK)
self.cykBtn.pack(side="top", expand=True, pady=8)
self.reBtn = Button(self.rightFrame, text='RegEx提取信息', command=self.onRE)
self.reBtn.pack(side="top", expand=True, pady=8)
# HINT: Place additional button here
self.quitBtn = Button(self.rightFrame, text="退出", command=self.onQuit)
self.quitBtn.pack(side="top", expand=True, pady=8)
def onQuit(self):
self.quit()
############################## BMM Segmentation #########################################
def onBMM(self):
self.outputText.delete('1.0', END)
inStr = self.inputText.get('1.0', END).strip()
start = time.clock()
result = self.bmm.BMM(inStr, self.inputText)
self.outputText.insert(INSERT, result)
elapsed = time.clock() - start
if result != '':
self.label2['text'] = '分词结果 耗时: ' + '{0:.1f} ms'.format(elapsed*1000)
######################### Maximum Probability Segmentation ###############################
def onMP(self):
self.outputText.delete('1.0', END)
inStr = self.inputText.get('1.0', END).strip()
start = time.clock()
result = self.mp.MaxProbability(inStr)
self.outputText.insert(INSERT, result)
elapsed = time.clock() - start
if result != '':
self.label2['text'] = '分词结果 耗时: ' + '{0:.1f} ms'.format(elapsed*1000)
############################## HMM Pos-tagging ##########################################
def onHMM(self):
self.outputText.delete('1.0', END)
inStr = self.inputText.get('1.0', END).strip()
if inStr == '':
return
start = time.clock()
segmented = self.mp.MaxProbability(inStr)
obs = [w.strip('/') for w in segmented.split()]
result = self.tagger.Viterbi(obs)
elapsed = time.clock() - start
self.outputText.insert(INSERT, result)
if result != '':
self.label2['text'] = '词性标注结果 耗时: ' + '{0:.1f} ms'.format(elapsed*1000)
############################## Top-down parsing #########################################
def onTopdownParse(self):
inStr = self.outputText.get('1.0', END).strip()
if inStr == '':
sentence = ['the', 'old', 'man', 'cried']
self.outputText.insert(INSERT, ' '.join(sentence))
else:
sentence = inStr.strip().split()
start = time.clock()
succeed = self.parser.parse(sentence)
elapsed = time.clock() - start
if succeed:
self.label2['text'] = '语法分析完成 结果：成功 耗时：' + '{0:.1f} ms'.format(elapsed*1000)
newWindow = Toplevel(self)
newWindow.title('自顶向下语法分析')
self.textbox = Entry(newWindow)
self.textbox.pack(fill=X, expand=1)
self.tree = Treeview(newWindow)
self.tree.heading('#0', text='语法树', anchor='w')
self.tree.pack(fill=BOTH, expand=1)
parseString = self.parser.printParseTree()
self.textbox.insert(INSERT, parseString)
self.buildParseTree_TopDown('', 'S', self.parser.rules, self.parser.choices)
else:
self.label2['text'] = '语法分析完成 结果：失败 耗时：' + '{0:.1f} ms'.format(elapsed*1000)
def onLoadRules_TopDown(self):
fname = askopenfilename(initialdir='./data', initialfile='rules.txt')
if fname != '':
self.inputText.delete('1.0', END)
with open(fname) as f:
self.inputText.insert(INSERT, f.read())
self.parser.loadRules(fname)
def buildParseTree_TopDown(self, parent, symbol, rules, choices):
if choices[symbol] == -1:
newNode = self.tree.insert(parent, 'end', text=symbol, open=True)
self.tree.insert(newNode, 'end', text=' | '.join(rules[symbol][0]))
else:
c = choices[symbol]
newParent = self.tree.insert(parent, 'end', text=symbol, open=True)
for symbl in rules[symbol][c]:
self.buildParseTree_TopDown(newParent, symbl, rules, choices)
############################## CYK-PCFG parsing #########################################
def onLoadRules_CYK(self):
fname = askopenfilename(initialdir='./data', initialfile='rules_pcfg.txt')
if fname != '':
self.inputText.delete('1.0', END)
with open(fname) as f:
self.inputText.insert(INSERT, f.read())
self.parser.loadRules(fname)
def buildParseTree_CYK(self, parent, beg, end, symbol_id):
backPt = self.cykParser.BP[beg][end][symbol_id]
symbol = self.cykParser.id2symb[symbol_id]
if backPt.s == -1:
newNode = self.tree.insert(parent, 'end', text=symbol, open=True)
self.tree.insert(newNode, 'end', text=self.cykParser.words[beg-1], open=True)
else:
newParent = self.tree.insert(parent, 'end', text=symbol, open=True)
self.buildParseTree_CYK(newParent, beg, backPt.s, backPt.Y)
self.buildParseTree_CYK(newParent, backPt.s+1, end, backPt.Z)
def onCYK(self):
inStr = self.outputText.get('1.0', END).strip()
if inStr == '':
sentence = 'fish people fish tanks'
self.outputText.insert(INSERT, sentence)
else:
sentence = inStr
start = time.clock()
parseString, prob = self.cykParser.parse(sentence)
elapsed = time.clock() - start
self.label2['text'] = 'PCFG语法分析完成 结果：成功 耗时：' + '{0:.1f} ms'.format(elapsed*1000)
newWindow = Toplevel(self)
newWindow.title('PCFG语法分析')
self.textbox = Entry(newWindow)
self.textbox.pack(fill=X, expand=1)
self.tree = Treeview(newWindow)
self.tree.heading('#0', text='语法树 (概率:{0:.8f})'.format(prob), anchor='w')
self.tree.pack(fill=BOTH, expand=1)
self.textbox.insert(INSERT, parseString)
self.buildParseTree_CYK('', 1, len(self.cykParser.words), self.cykParser.symb2id['S'])
def onRE(self):
window = Toplevel(self)
window.title('正则表达式信息提取')
label = Label(window)
label.pack()
result = ScrolledText(window)
result.pack(fill=BOTH, expand=1)
htmlFile = 'data/凤凰网.html'
start = time.clock()
titles = regex.fetchTitles(htmlFile)
links = regex.fetchLinks(htmlFile)
elapsed = time.clock() - start
label['text'] = '耗时: {0:.1f} ms'.format(elapsed*1000)
result.insert(INSERT, 'Titles:\n')
result.insert(INSERT, '\n'.join(titles))
result.insert(INSERT, '\n\nLinks:\n')
result.insert(INSERT, '\n'.join(links))
class OptimizerMainWindow:
"""
classdocs
"""
# TODO: change that name
def reactToClick(self, event):
a = AddRestrictionDialog(self)
def __init__(self, optimizer):
# always have a reference to model/controller
self.optimizer = optimizer
# setup main GUI and make stretchable
self.guiRoot = Tk()
self.guiRoot.title("OPTIMIZR")
self.guiRoot.columnconfigure(1, weight=1)
self.guiRoot.rowconfigure(0, weight=1)
# left (settings) and right (sequences) part
self.frameLeft = Frame(self.guiRoot)
self.frameLeft.grid(row=0, column=0, sticky=W + E + N + S)
self.frameLeft.columnconfigure(0, weight=1)
self.frameRight = Frame(self.guiRoot)
self.frameRight.grid(row=0, column=1, sticky=W + E + N + S)
self.frameRight.columnconfigure(0, weight=1)
self.frameRight.rowconfigure(0, weight=1)
self.frameRight.rowconfigure(1, weight=1)
self.frameSpeciesControll = LabelFrame(self.frameLeft, text="Species", pady=10, padx=10)
self.frameSpeciesControll.columnconfigure(1, weight=1)
self.frameOptimizationControll = LabelFrame(self.frameLeft, text="Optimization", pady=10, padx=10)
self.frameRestrictionControll = LabelFrame(self.frameLeft, text="Restriction Enzymes", pady=10, padx=10)
self.frameSpeciesControll.grid(row=0, column=0, sticky=W + E, padx=10, pady=10)
self.frameOptimizationControll.grid(row=1, column=0, sticky=W + E, padx=10, pady=10)
self.frameRestrictionControll.grid(row=2, column=0, sticky=W + E, padx=10, pady=10)
# Species Controll
Label(self.frameSpeciesControll, text="Source:").grid(row=0, column=0)
Label(self.frameSpeciesControll, text="Target:").grid(row=1, column=0)
self.comboSourceSpecies = Combobox(self.frameSpeciesControll, state="readonly")
self.comboSourceSpecies.grid(row=0, column=1, pady=5, sticky="ew")
self.comboTargetSpecies = Combobox(self.frameSpeciesControll, state="readonly")
self.comboTargetSpecies.grid(row=1, column=1, pady=5, sticky="we")
self.buttonSpeciesList = Button(self.frameSpeciesControll, text="Edit Species List")
self.buttonSpeciesList.grid(row=2, column=1, pady=5, sticky="e")
self.comboSourceSpecies.bind("<<ComboboxSelected>>", self.actionOptimizerSettingsChanged)
self.comboTargetSpecies.bind("<<ComboboxSelected>>", self.actionOptimizerSettingsChanged)
# Optimization Controll
Label(self.frameOptimizationControll, text="Optimization Strategy:").grid(row=0, column=0)
self.comboOptimizationStrategy = Combobox(self.frameOptimizationControll, state="readonly")
self.comboOptimizationStrategy.grid(row=0, column=1)
self.comboOptimizationStrategy["values"] = self.optimizer.possibleOptimizationStrategies
self.comboOptimizationStrategy.bind("<<ComboboxSelected>>", self.actionOptimizerSettingsChanged)
# Restriction Enzymes
self.listRestriction = Listbox(self.frameRestrictionControll)
self.listRestriction.grid(row=0, column=0, columnspan=3, pady=5, sticky=W + E)
self.frameRestrictionControll.columnconfigure(0, weight=1)
self.buttonRestricionAdd = Button(self.frameRestrictionControll, text=" + ")
self.buttonRestricionDel = Button(self.frameRestrictionControll, text=" - ")
self.buttonRestricionAdd.grid(row=1, column=1, padx=5)
self.buttonRestricionDel.grid(row=1, column=2, padx=5)
# Source Sequence Frame
self.frameSourceSequence = LabelFrame(self.frameRight, text="Source Sequence", padx=10, pady=10)
self.frameResultSequence = LabelFrame(self.frameRight, text="Result Sequence", padx=10, pady=10)
self.frameSourceSequence.grid(row=0, column=0, sticky="wens", padx=10, pady=10)
self.frameResultSequence.grid(row=1, column=0, sticky="wens", padx=10, pady=10)
self.buttonSourceLoad = Button(self.frameSourceSequence, text=" Load ")
self.textSourceSeq = ScrolledText(self.frameSourceSequence, height=10)
self.buttonSourceLoad.grid(row=0, column=1, sticky="e", pady=5)
self.textSourceSeq.grid(row=1, column=0, columnspan=2, sticky="wens")
self.frameSourceSequence.columnconfigure(0, weight=1)
self.frameSourceSequence.rowconfigure(1, weight=1)
self.textSourceSeq.frame.columnconfigure(1, weight=1)
self.textSourceSeq.frame.rowconfigure(0, weight=1)
self.buttonOptimize = Button(self.frameResultSequence, text=" OPTIMIZE! ")
self.buttonOptimize.bind("<ButtonRelease>", self.actionOptimize)
self.buttonRemoveRestriction = Button(self.frameResultSequence, text=" RESTRICTION-B-GONE! ")
self.buttonRemoveRestriction.bind("<ButtonRelease>", self.actionRemoveRestricion)
self.buttonSaveResult = Button(self.frameResultSequence, text=" Save ")
self.textResultSequence = ScrolledText(self.frameResultSequence, height=10)
self.buttonOptimize.grid(column=0, row=0, pady=5, sticky="w")
self.buttonRemoveRestriction.grid(column=1, row=0, pady=5, padx=10, sticky="w")
self.textResultSequence.grid(row=1, column=0, columnspan=4, sticky="wens")
self.buttonSaveResult.grid(row=2, column=3, pady=5, sticky="e")
self.frameResultSequence.columnconfigure(2, weight=1)
self.frameResultSequence.rowconfigure(1, weight=1)
self.textResultSequence.frame.columnconfigure(1, weight=1)
self.textResultSequence.frame.rowconfigure(0, weight=1)
self.textSourceSeq.bind("<<Modified>>", self.actionSequenceModified)
self.textResultSequence.bind("<<Modified>>", self.actionSequenceModified)
# generate color tags for textboxes
for i in range(101):
# green for normal codons
(r, g, b) = colorsys.hsv_to_rgb(210 / 360, i / 100, 1.0)
colorHex = "#%02x%02x%02x" % (int(r * 255), int(g * 255), int(b * 255))
self.textSourceSeq.tag_config("normal" + str(i), background=colorHex)
self.textResultSequence.tag_config("normal" + str(i), background=colorHex)
# red for codons with restriction sites
(r, g, b) = colorsys.hsv_to_rgb(5 / 360, i / 100, 1.0)
colorHex = "#%02x%02x%02x" % (int(r * 255), int(g * 255), int(b * 255))
self.textSourceSeq.tag_config("restrict" + str(i), background=colorHex)
self.textResultSequence.tag_config("restrict" + str(i), background=colorHex)
# Set (minimum + max) Window size
self.guiRoot.update()
self.guiRoot.minsize(self.guiRoot.winfo_width(), self.guiRoot.winfo_height())
self.buttonRestricionAdd.bind("<ButtonRelease>", self.reactToClick)
self.buttonRestricionDel.bind("<ButtonRelease>", self.actionRestrictionEnzymeDelete)
self.buttonSpeciesList.bind("<ButtonRelease>", self.actionEditSpeciesButton)
self.buttonSourceLoad.bind("<ButtonRelease>", self.actionLoadSequence)
self.buttonSaveResult.bind("<ButtonRelease>", self.actionSaveSequence)
# TEST
# self.listRestriction.insert("end", "EcoRI")
# self.listRestriction.insert("end", "BamHI")
#
# dummy event to manually trigger update
self.guiRoot.bind("<<Update>>", self.actionUpdate)
self.actionUpdate(None)
self.guiRoot.mainloop()
def actionRestrictionEnzymeDelete(self, event):
try:
selectedEnzyme = self.listRestriction.selection_get()
self.optimizer.restrictionEnzymeList.remove(selectedEnzyme)
self.guiRoot.event_generate("<<Update>>")
except tkinter.TclError:
# no selection
pass
def actionUpdate(self, event):
# print("update called")
# clear list of restriction enzymes
self.listRestriction.delete(0, "end")
for r in self.optimizer.restrictionEnzymeList:
self.listRestriction.insert("end", r)
self.comboSourceSpecies.delete(0, "end")
self.comboTargetSpecies.delete(0, "end")
speciesValues = list()
for (taxid, name) in self.optimizer.speciesList:
speciesValues.append(taxid + ": " + name)
self.comboSourceSpecies["values"] = speciesValues
self.comboTargetSpecies["values"] = speciesValues
if self.comboSourceSpecies.get() not in speciesValues:
self.comboSourceSpecies.set("")
if self.comboTargetSpecies.get() not in speciesValues:
self.comboTargetSpecies.set("")
self.textSourceSeq.edit_modified(True)
self.textResultSequence.edit_modified(True)
self.optimizer.saveConfig("config.ini")
def actionEditSpeciesButton(self, event):
speciesListDialog = SpeciesListDialog(self)
def actionOptimizerSettingsChanged(self, event=None):
# print("Something happened")
strategy = self.comboOptimizationStrategy.get()
sourceString = self.comboSourceSpecies.get()
targetString = self.comboTargetSpecies.get()
if not (strategy and sourceString and targetString):
return
sourceTaxid = sourceString.split(":")[0]
targetTaxid = targetString.split(":")[0]
self.optimizer.setOptimizer(sourceTaxid, targetTaxid, strategy)
self.textSourceSeq.edit_modified(True)
self.textResultSequence.edit_modified(True)
# self.optimizer.testPrint()
def actionOptimize(self, event=None):
self.optimizer.runOptimization()
self.textSourceSeq.edit_modified(True)
self.textResultSequence.edit_modified(True)
def actionRemoveRestricion(self, event=None):
self.optimizer.runRestricionRemoval()
self.textSourceSeq.edit_modified(True)
self.textResultSequence.edit_modified(True)
def actionSequenceModified(self, event=None):
# necessary if, otherwise -> infinite loop
if self.textSourceSeq.edit_modified():
seq = self.textSourceSeq.get("1.0", "end").strip()
seq = stripCharsNotInList(seq.upper(), ["A", "C", "G", "T"])
self.optimizer.setSourceSeq(seq)
oldInsert = self.textSourceSeq.index("insert")
self.textSourceSeq.delete("1.0", "end")
sourceCodons = self.optimizer.getCodonsForPrint(True)
if not sourceCodons:
self.textSourceSeq.insert("end", self.optimizer.sourceSequence)
else:
for (co, sc, r) in sourceCodons:
if sc:
if not r:
self.textSourceSeq.insert("end", co, "normal" + str(int(sc * 100)))
# print("normal"+str(int(sc*100)))
else:
self.textSourceSeq.insert("end", co, "restrict" + str(int(sc * 100)))
else:
# remainder without color
self.textSourceSeq.insert("end", co)
self.textSourceSeq.mark_set("insert", oldInsert)
# reset the modified status at the very end
self.textSourceSeq.edit_modified(False)
if self.textResultSequence.edit_modified():
seq = self.textResultSequence.get("1.0", "end").strip()
# self.optimizer.setOptimizedSeq(seq)
oldInsert = self.textResultSequence.index("insert")
self.textResultSequence.delete("1.0", "end")
targetCodons = self.optimizer.getCodonsForPrint(False)
if not targetCodons:
self.textSourceSeq.insert("end", self.optimizer.optimizedSequence)
else:
for (co, sc, r) in targetCodons:
if sc:
if not r:
self.textResultSequence.insert("end", co, "normal" + str(int(sc * 100)))
# print("normal"+str(int(sc*100)))
else:
self.textResultSequence.insert("end", co, "restrict" + str(int(sc * 100)))
else:
# remainder without color
self.textResultSequence.insert("end", co)
self.textSourceSeq.mark_set("insert", oldInsert)
self.textResultSequence.edit_modified(False)
def actionLoadSequence(self, event=None):
filename = tkinter.filedialog.askopenfilename()
if filename:
seq = sequenceIO.readFile(filename)
self.textSourceSeq.delete("1.0", "end")
self.textSourceSeq.insert("end", seq)
self.textSourceSeq.edit_modified(True)
def actionSaveSequence(self, event=None):
filename = tkinter.filedialog.asksaveasfilename()
if filename:
# print("file is " + filename)
with open(filename, mode="w") as fd:
fd.write(self.optimizer.optimizedSequence)
class AppletEditTimecard(object): # pylint: disable=too-many-instance-attributes
""""""
def __init__(self, parent):
""""""
self.parent = parent
self.timecard_obj = None
self.edit_amt_app = None
self.root = tkinter.Toplevel()
self.root.iconify()
self.root.title('Edit Timecard')
self.root.geometry('800x%s' % 600)
self.msgvar = tkinter.StringVar(self.root)
self.date = tkinter.StringVar(self.root)
tkinter.Label(
self.root,
text='Description'
).grid(row=0, column=0)
self.msg = tkinter.Message(
self.root,
textvariable=self.msgvar
).grid(row=0, column=1, sticky=tkinter.E)
tkinter.Label(
self.root,
text='Date'
).grid(row=1, column=0, sticky=tkinter.E)
tkinter.Entry(
self.root,
textvariable=self.date
).grid(row=1, column=1, sticky=tkinter.W)
tkinter.Label(
self.root,
text='Notes'
).grid(row=2, column=0, sticky=tkinter.E)
self.notes_entry = ScrolledText(self.root, height=10)
self.notes_entry.grid(row=2, column=1, sticky=tkinter.W)
tkinter.Label(
self.root,
text='Period Start'
).grid(row=3, column=0, sticky=tkinter.E)
self.period_start = tkinter.StringVar(self.root)
self.period_start_entry = tkinter.Entry(self.root, textvariable=self.period_start)
self.period_start_entry.grid(row=3, column=1, sticky=tkinter.W)
period_end_label = tkinter.Label(self.root, text='Period End')
period_end_label.grid(row=4, column=0, sticky=tkinter.E)
self.period_end = tkinter.StringVar(self.root)
self.period_end_entry = tkinter.Entry(self.root, textvariable=self.period_end)
self.period_end_entry.grid(row=4, column=1, sticky=tkinter.W)
message_label = tkinter.Label(self.root, text='Message')
message_label.grid(row=5, column=0, sticky=tkinter.E)
self.message_entry = tkinter.Text(self.root, height=2)
self.message_entry.grid(row=5, column=1, sticky=tkinter.W)
button_frame = tkinter.Frame(self.root)
button_frame.grid(row=6, column=1, sticky=tkinter.E)
save_button = tkinter.Button(
button_frame,
text="Save",
name="save-button",
command=self.save_btn,
padx=7, pady=2)
save_button.pack(side='left')
edit_amounts_btn = tkinter.Button(
button_frame,
text="Edit Amounts",
name="edit-amounts-button",
command=self.edit_amounts_btn_cb,
padx=7, pady=2)
edit_amounts_btn.pack(side='left')
cancel_button = tkinter.Button(
button_frame,
text="Cancel",
name="cancel-button",
command=self.cancel_btn,
padx=7, pady=2)
cancel_button.pack(side='left')
def cancel_btn(self):
""""""
self.parent.root.deiconify()
self.root.iconify()
def edit_amounts_btn_cb(self):
""""""
if self.edit_amt_app is None:
self.edit_amt_app = AppletEditTimecardAmounts(self)
self.root.iconify()
self.edit_amt_app.root.deiconify()
self.edit_amt_app.set_edit_form(self.timecard_obj)
def form_to_obj(self):
"""Update Timecard obj from form"""
self.timecard_obj.period_start = dt.strptime(self.period_start.get(),
api.DATE_INPUT_FORMAT).strftime(api.DATE_ISO_FORMAT)
self.timecard_obj.period_end = dt.strptime(
self.period_end.get(), api.DATE_INPUT_FORMAT).strftime(api.DATE_ISO_FORMAT)
self.timecard_obj.date = dt.strptime(self.date.get(), api.DATE_INPUT_FORMAT).strftime(api.DATE_ISO_FORMAT)
self.timecard_obj.message = self.message_entry.get('1.0', 'end-1c')
self.timecard_obj.notes = self.notes_entry.get('1.0', 'end-1c')
def save_btn(self):
"""Saves edited timecard before posting."""
self.form_to_obj()
print(self.timecard_obj.to_dict())
result = api.TimecardSchema().load(self.timecard_obj.to_dict())
if result.errors:
print(result.errors)
else:
lib.save_timecard(self.timecard_obj.to_dict())
self.root.iconify()
self.parent.root.deiconify()
self.parent.load()
def set_edit_form(self, timecard_dict):
""""""
self.timecard_obj = api.Timecard(**timecard_dict)
self.root.title('Edit Timecard Number %s' % self.timecard_obj.id)
self.date.set(dt.strptime(
self.timecard_obj.date,
api.DATE_ISO_FORMAT).strftime(api.DATE_INPUT_FORMAT))
self.notes_entry.delete('1.0', tkinter.END)
self.notes_entry.insert(
tkinter.END, self.timecard_obj.notes if self.timecard_obj.notes else '')
self.period_start.set(
dt.strptime(
self.timecard_obj.period_start,
api.DATE_ISO_FORMAT).strftime(api.DATE_INPUT_FORMAT))
self.period_end.set(
dt.strptime(
self.timecard_obj.period_end, api.DATE_ISO_FORMAT).strftime(api.DATE_INPUT_FORMAT))
self.message_entry.delete('1.0', tkinter.END)
self.message_entry.insert(
tkinter.END, self.timecard_obj.message if self.timecard_obj.message else '')
self.update_summary()
def update_summary(self):
""""""
set_edit_timecard_msg(self.msgvar, self.timecard_obj)
class Application(ttk.Frame):
def __init__(self, master=None):
# ttk.Frame is an old-style class on 2.7
ttk.Frame.__init__(self, master)
self._init_ui()
self.pack()
env = os.environ.copy()
env['RUST_LOG'] = 'info'
self.wrapper = WrapperProcessMonitor(('bin/wrapper',), env=env)
self.wrapper.on_event = self._handle_wrapper_event
module = 'http.server' if py3 else 'SimpleHTTPServer'
self.http = ProcessMonitor((sys.executable, '-u', '-m', module, '8889'),
cwd=os.path.join(os.getcwd(), 'www'))
self.http.on_event = self._handle_http_event
self.repl = ReplConnection()
self.repl.on_event = self._handle_repl_event
self.stopping = 0
self.master.protocol('WM_DELETE_WINDOW', self._handle_close)
self.after(100, self._check_queues)
def _init_ui(self):
frame_top = ttk.Frame(self)
notebook = ttk.Notebook(self)
self.btn_start = ttk.Button(frame_top, text='Start Server', command=self._start)
self.btn_stop = ttk.Button(frame_top, text='Stop Server', command=self._stop)
self.btn_stop.state(['disabled'])
self.btn_start.pack(side='left')
self.btn_stop.pack(side='right')
notebook.add(self._init_status_frame(notebook), text='Status')
notebook.add(self._init_repl_frame(notebook), text='REPL')
self.wrapper_log = ScrolledText(notebook, height=20, width=80)
notebook.add(self.wrapper_log, text='Main Log')
self.http_log = ScrolledText(notebook, height=20, width=80)
notebook.add(self.http_log, text='HTTP Log')
frame_top.pack()
notebook.pack()
def _init_status_frame(self, notebook):
wrapper = ttk.Frame(notebook)
frame = ttk.Frame(wrapper)
ttk.Label(frame, text='Main Server: ').grid(row=0, column=0, sticky='W')
ttk.Label(frame, text='HTTP Server: ').grid(row=1, column=0, sticky='W')
self.status_wrapper = ttk.Label(frame, text='Not running')
self.status_wrapper.grid(row=0, column=1, sticky='W')
self.status_http = ttk.Label(frame, text='Not running')
self.status_http.grid(row=1, column=1, sticky='W')
self.status_extra = ttk.Label(frame, text='')
self.status_extra.grid(row=2, column=0, columnspan=2)
frame.pack()
return wrapper
def _init_repl_frame(self, notebook):
frame = ttk.Frame(notebook)
self.repl_input = ScrolledText(frame, height=15, width=80)
self.repl_input.insert(tk.END,
'-- REPL command input\n'
'-- Press Ctrl-Enter to run command\n'
'client_by_name(\'OP\'):extra().superuser = true')
self.repl_input.bind('<Control-Return>', self._repl_send)
self.repl_input.pack()
self.repl_output = ScrolledText(frame, height=5, width=80)
self.repl_output.pack()
return frame
def _handle_wrapper_event(self, kind, data):
self._log_event(self.wrapper_log, kind, data)
if kind in ('error', 'result'):
if self.stopping > 0:
self.stopping -= 1
stat = 'down'
else:
stat = 'err'
self._update_status(wrapper=stat)
def _handle_http_event(self, kind, data):
self._log_event(self.http_log, kind, data)
if kind in ('error', 'result'):
if self.stopping > 0:
self.stopping -= 1
stat = 'down'
else:
stat = 'err'
self._update_status(http=stat)
def _repl_send(self, evt):
cmd = self.repl_input.get('1.0', tk.END)
cmd = '{\n%s\n}\n' % cmd
try:
self.repl.send(cmd)
except (IOError, OSError) as e:
append_text(self.repl_output, '\n\nError sending command: %s' % e)
return 'break'
def _handle_repl_event(self, kind, data):
if kind == 'recv':
append_text(self.repl_output, data.decode('utf-8'))
def _log_event(self, log, kind, data):
if kind == 'error':
append_text(log, '\n\nError reading output: %s' % data.decode())
elif kind == 'result':
append_text(log, '\n\nProcess exited with code %d' % data)
elif kind == 'output':
append_text(log, data.decode())
def _check_queues(self):
self.wrapper.poll()
self.http.poll()
self.repl.poll()
self.after(100, self._check_queues)
def _start(self):
if os.name == 'posix':
if os.path.exists('control'):
os.remove('control')
if os.path.exists('repl'):
os.remove('repl')
try:
self.wrapper.start()
wrapper_ok = 'up'
except OSError as e:
append_text(self.wrapper_log, '\n\nError starting main server: %s' % e)
wrapper_ok = 'err'
try:
self.http.start()
http_ok = 'up'
except OSError as e:
append_text(self.http_log, '\n\nError starting HTTP server: %s' % e)
http_ok = 'err'
self._update_status(wrapper=wrapper_ok, http=http_ok)
self.btn_start.state(['disabled'])
self.btn_stop.state(['!disabled'])
def _stop(self):
self.stopping = 2
self.wrapper.stop()
self.http.stop()
self.repl.close()
self.btn_start.state(['!disabled'])
self.btn_stop.state(['disabled'])
def _update_status(self, wrapper=None, http=None):
STATUS_TEXT = {
'up': 'Running',
'down': 'Not running',
'err': 'Error (see log)',
}
if wrapper is not None:
self.status_wrapper.config(text=STATUS_TEXT[wrapper])
if http is not None:
self.status_http.config(text=STATUS_TEXT[http])
if wrapper == 'up' and http == 'up':
self.status_extra.config(
text='Visit http://localhost:8889/client.html to play')
else:
self.status_extra.config(text='')
def _handle_close(self):
self._stop()
self.quit()
class GenericGUI(elflab.abstracts.UIBase):
# CONSTANTS
DEFAULT_FOLDER = r"d:\data_dump"
DEFAULT_FN = r"datalog"
PATH_LENGTH = 50
FN_LENGTH = 20
VAR_NUM_FORMAT = "{}{}={:.5g}; "
VAR_STR_FORMAT = "{}{}={}; "
PARAM_LENGTH = 15
UI_REFRESH = 0.1 # Update ui every #seconds
STATUS_REFRESH = 1.0 # Update the status frame every # seconds
CONTROLLER_REFRESH = 5.0 # Update controller status every #seconds
# default values to pass on to the kernel
DEFAULT_PLOT_REFRESH_INTERVAL = 0.5 # Interval between plot refreshes in s
DEFAULT_PLOT_LISTEN_INTERVAL = 0.05 # Interval between listening events in s
def __init__(self, Kernel, Experiment, Controller=None, subplots=None): # subplots: overwrite if not None
# 0=stoped, 1=running, 2=paused
self.state = -1
# saving arguments
self.Kernel = Kernel
self.Experiment = Experiment
self.Controller = Controller
self.subplots = subplots
self.params = Experiment.default_params.copy()
if Experiment.param_order is None:
self.param_order = list(self.params.keys())
else:
self.param_order = Experiment.param_order
self.var_order = Experiment.var_order
self.var_titles = Experiment.var_titles
# declare objects
self.kernel = None
self.experiment = None
self.controller = None
# setting gui root
self.root = tk.Tk()
try:
title = "{}: {}".format(Kernel.title, Experiment.title)
except Exception:
title = "Undefined Kernel Title"
self.root.title(title)
# Declare containers
self.folder_str = self.DEFAULT_FOLDER
self.filename_var = tk.StringVar()
self.filename_var.set(self.DEFAULT_FN)
# Declare other variables
self.controller_time = self.status_time = time.perf_counter()
self.instrument_lock = multiprocessing.Lock()
self.data_lock = multiprocessing.Lock()
self.ui_lock = multiprocessing.Lock()
self.controller_lock = multiprocessing.Lock()
self.kernel_kwargs = {
"plot_refresh_interval": self.DEFAULT_PLOT_REFRESH_INTERVAL,
"plot_listen_interval": self.DEFAULT_PLOT_LISTEN_INTERVAL,
"data_lock": self.data_lock,
"instrument_lock": self.instrument_lock,
}
self.controller_kwargs = {}
# Define styles
style = ttk.Style()
style.configure("RedFG.TButton", foreground="red")
style.configure("GreenBG.TButton", background="green")
# Define the scrolling frame
self.ybar = ttk.Scrollbar(self.root, orient=tk.VERTICAL)
self.ybar.grid(row=0, column=1, sticky="ns")
self.xbar = ttk.Scrollbar(self.root, orient=tk.HORIZONTAL)
self.xbar.grid(row=1, column=0, sticky="we")
self.mainCanvas = tk.Canvas(self.root)
self.mainCanvas.grid(row=0, column=0, sticky="nswe")
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
self.mainFrame = ttk.Frame(self.mainCanvas)
self.mainCanvas.create_window((0, 0), window=self.mainFrame, anchor=tk.NW)
# Contents - layout frames
self.fileFrame = ttk.LabelFrame(self.mainFrame, text="Data File")
self.fileFrame.grid(row=0, column=0, columnspan=3, sticky="we")
self.paramFrame = ttk.LabelFrame(self.mainFrame, text="Parameters")
self.paramFrame.grid(row=1, column=0, rowspan=3, sticky="nswe")
self.commentFrame = ttk.LabelFrame(self.mainFrame, text="comments")
self.commentFrame.grid(row=1, column=1, sticky="nwe")
self.commandFrame = ttk.LabelFrame(self.mainFrame, text="Program Control")
self.commandFrame.grid(row=1, column=2, sticky="nwe")
self.controlFrame = ttk.Frame(self.mainFrame, relief="solid")
self.controlFrame.grid(row=2, column=1, columnspan=2, sticky="nwe", padx=5, pady=5)
self.statusFrame = ttk.LabelFrame(self.mainFrame, text="status")
self.statusFrame.grid(row=3, column=1, columnspan=2, sticky="nwe")
# File options
self.file_label1 = ttk.Label(self.fileFrame, text='file name: "(time stamp)_')
self.file_label1.pack(side=tk.LEFT)
self.file_entry = ttk.Entry(self.fileFrame, width=self.FN_LENGTH, textvariable=self.filename_var)
self.file_entry.pack(side=tk.LEFT)
self.file_label2 = ttk.Label(self.fileFrame, text='.dat"')
self.file_label2.pack(side=tk.LEFT)
self.folder_button = ttk.Button(self.fileFrame, text="directory", command=self.change_folder)
self.folder_button.pack(side=tk.LEFT, padx=(32, 0))
self.folder_label = ttk.Label(self.fileFrame, width=self.PATH_LENGTH, justify=tk.LEFT)
self.folder_label.pack(side=tk.LEFT)
self.set_folder(self.folder_str)
# Parameters
self.param_vars = {}
r = 0
for par in self.param_order:
w = ttk.Label(self.paramFrame, text=par)
w.grid(column=0, row=r, sticky="nw")
self.param_vars[par] = tk.StringVar()
self.param_vars[par].set(self.params[par])
w = ttk.Entry(self.paramFrame, width=self.PARAM_LENGTH, textvariable=self.param_vars[par])
w.grid(column=0, row=r + 1, sticky="nw", pady=(0, 8))
r += 2
# Comments box
self.comment_button = ttk.Button(
self.commentFrame, text="update", command=self.update_comment, state="disabled"
)
self.comment_button.grid(row=0, column=0, sticky="nw")
self.comment_box = ScrolledText(self.commentFrame, width=40, height=8)
self.comment_box.insert(0.0, Experiment.default_comments)
self.comment_box.grid(row=1, column=0, sticky="nw")
# commands
self.kernelLabel = ttk.Label(
self.commandFrame,
text="stopped",
anchor=tk.CENTER,
foreground="white",
background="dim gray",
relief="groove",
)
self.kernelLabel.grid(column=1, row=1, sticky="ew")
self.buttonStart = ttk.Button(self.commandFrame, text="start", command=self.start_kernel)
self.buttonStart.grid(column=1, row=2, sticky="ew")
self.buttonPause = ttk.Button(self.commandFrame, text="pause", command=self.pause_kernel, state="disabled")
self.buttonPause.grid(column=1, row=3, sticky="ew")
self.buttonQuit = ttk.Button(self.commandFrame, text="quit", style="RedFG.TButton", command=self.quit)
self.buttonQuit.grid(column=1, row=4, sticky="ew")
self.buttonPlot = ttk.Button(self.commandFrame, text="plot", command=self.kernel_plot, state="disabled")
self.buttonPlot.grid(column=2, row=1, sticky="ew")
self.buttonAutoOn = ttk.Button(
self.commandFrame, text="autoscale: on", command=self.kernel_autoscaleOn, state="disabled"
)
self.buttonAutoOn.grid(column=2, row=2, sticky="ew")
self.buttonAutoOff = ttk.Button(
self.commandFrame, text="autoscale: off", command=self.kernel_autoscaleOff, state="disabled"
)
self.buttonAutoOff.grid(column=2, row=3, sticky="ew")
self.buttonClear = ttk.Button(
self.commandFrame, text="clear plots", command=self.kernel_clearPlot, state="disabled"
)
self.buttonClear.grid(column=2, row=4, sticky="ew")
for child in self.commandFrame.winfo_children():
child.grid_configure(padx=5, pady=5)
# Status
st = ""
for var in self.var_order:
st = self.VAR_STR_FORMAT.format(st, self.var_titles[var], "not available")
self.statusLabel = ttk.Label(self.statusFrame, text=st, justify=tk.LEFT, foreground="blue")
self.statusLabel.grid(sticky="nw")
def quit(self):
if self.kernel is not None:
self.kernel.quit()
if self.controller is not None:
self.controller.terminate()
self.root.quit()
def start(self):
# Calculate the wrapping length for status
self.mainFrame.update()
w = self.commentFrame.winfo_reqwidth() + self.commandFrame.winfo_reqwidth() - 1
self.statusLabel.configure(wraplength=w)
# Update Frames and Define the scrolling
self.mainFrame.update()
self.mainCanvas.config(
width=self.mainFrame.winfo_reqwidth(),
height=self.mainFrame.winfo_reqheight(),
scrollregion=(0, 0, self.mainFrame.winfo_reqwidth(), self.mainFrame.winfo_reqheight()),
)
self.ybar.config(command=self.mainCanvas.yview)
self.xbar.config(command=self.mainCanvas.xview)
self.mainCanvas.config(xscrollcommand=self.xbar.set, yscrollcommand=self.ybar.set)
# Start the gui
self.root.after(0, self.update_interface)
self.root.mainloop()
def error_box(self, err):
messagebox.showerror(
"Error", "An error has occurred, try checking the values entered.\n error code:\n {}".format(err)
)
def change_folder(self):
folder = filedialog.askdirectory()
self.set_folder(folder)
def set_folder(self, folder):
self.folder_str = folder
l = len(folder)
if l <= self.PATH_LENGTH:
folder_txt = folder
else:
folder_txt = "...{}".format(self.folder_str[-self.PATH_LENGTH + 3 : l])
self.folder_label.config(text=folder_txt)
def update_comment(self):
with open(self.comments_file, "a") as f:
f.write("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n")
f.write("\nUPDATE:\n")
f.write("Local time (YYYY/MM/DD, HH:MM:SS): {}\n".format(time.strftime("%Y/%m/%d, %H:%M:%S")))
f.write("____________________________________________________________\n")
t = self.comment_box.get(0.0, tk.END)
f.write(t)
# Recursively disable / enable widgets
def set_widget_state(self, w, state):
if "frame" in w.winfo_class().lower():
for child in w.winfo_children():
self.set_widget_state(child, state)
elif "text" not in w.winfo_class().lower():
w.configure(state=state)
# Refresh UI according to the state
def set_ui_state(self, state):
with self.ui_lock:
self.state = state
# Disable / enable widgets
if state > 0:
s1 = "disable"
s2 = "normal"
self.buttonStart.configure(text="stop", style="GreenBG.TButton", command=self.stop_kernel)
else:
s1 = "normal"
s2 = "disable"
self.buttonStart.configure(text="start", style="TButton", command=self.start_kernel)
self.set_widget_state(self.fileFrame, s1)
self.set_widget_state(self.paramFrame, s1)
self.comment_button.configure(state=s2)
self.buttonPause.configure(state=s2)
self.buttonPlot.configure(state=s2)
self.buttonAutoOn.configure(state=s2)
self.buttonAutoOff.configure(state=s2)
self.buttonClear.configure(state=s2)
self.set_widget_state(self.controlFrame, s2)
# update state label
if state == 0:
self.kernelLabel.configure(text="stopped", foreground="white", background="dim gray")
elif state == 1:
self.kernelLabel.configure(text="running", background="green", foreground="white")
self.buttonPause.configure(text="pause", style="TButton", command=self.pause_kernel)
else:
self.kernelLabel.configure(text="paused", background="yellow", foreground="")
self.buttonPause.configure(text="resume", style="GreenBG.TButton", command=self.resume_kernel)
def start_kernel(self):
try:
# Read parameters
for par in self.params:
self.params[par] = self.param_vars[par].get()
if self.kernel is not None:
self.kernel.quit()
# Parse file names, and create the comments file
filename = self.filename_var.get()
timestring = time.strftime("%Y.%m.%d_%H.%M.%S")
self.data_file = os.path.join(self.folder_str, "{0}_{1}.dat".format(timestring, filename))
self.comments_file = os.path.join(self.folder_str, "{0}_{1}_comments.txt".format(timestring, filename))
with open(self.comments_file, "w") as f:
f.write('experiment: "{}"\n'.format(self.Experiment.title))
f.write("Local time (YYYY/MM/DD, HH:MM:SS): {}\n".format(time.strftime("%Y/%m/%d, %H:%M:%S")))
f.write("____________________________________________________________\n")
t = self.comment_box.get(0.0, tk.END)
f.write(t)
f.write("\n\nParameters:\n")
for par in self.param_order:
f.write(" {} = {}\n".format(par, self.params[par]))
# Start the experiment and the kernel
self.experiment = self.Experiment(params=self.params, filename=self.data_file)
if self.subplots is not None:
self.experiment.plotXYs = self.subplots
self.kernel = self.Kernel(self.experiment, **self.kernel_kwargs)
self.kernel.start()
# Restart a controller instance
if self.controller is not None:
with self.controller_lock:
self.controller.terminate()
if self.Controller is not None:
self.controller = self.Controller(kernel=self.kernel, **self.controller_kwargs)
self.update_controller()
except Exception as err:
self.error_box(err)
print(traceback.format_exc())
else:
with self.ui_lock:
self.buttonStart.configure(text="stop", style="GreenBG.TButton", command=self.stop_kernel)
def stop_kernel(self):
self.kernel.stop()
def pause_kernel(self):
self.kernel.pause()
with self.ui_lock:
self.buttonPause.configure(text="resume", style="GreenBG.TButton", command=self.resume_kernel)
def resume_kernel(self):
self.kernel.resume()
with self.ui_lock:
self.buttonPause.configure(text="pause", style="TButton", command=self.pause_kernel)
def kernel_plot(self):
self.kernel.plot()
def kernel_autoscaleOn(self):
self.kernel.autoscaleOn()
def kernel_autoscaleOff(self):
self.kernel.autoscaleOff()
def kernel_clearPlot(self):
self.kernel.clearPlot()
# book keeping: update the controller status
def update_controller(self):
self.controller_time = time.perf_counter()
def update_status(self):
st = ""
with self.data_lock:
for var in self.var_order:
v = self.kernel.current_values[var]
if isinstance(v, float):
st = self.VAR_NUM_FORMAT.format(st, self.var_titles[var], v)
else:
st = self.VAR_STR_FORMAT.format(st, self.var_titles[var], v)
with self.ui_lock:
self.statusLabel.configure(text=st)
self.status_time = time.perf_counter()
# book keeping: update the interface
def update_interface(self):
if (self.kernel is None) or self.kernel.flag_stop or self.kernel.flag_quit:
new_state = 0
elif self.kernel.flag_pause:
new_state = 2
else:
new_state = 1
if new_state != self.state:
self.set_ui_state(new_state)
t = time.perf_counter()
if (self.state > 0) and (t - self.status_time > self.STATUS_REFRESH):
self.update_status()
if (self.state > 0) and (t - self.controller_time > self.CONTROLLER_REFRESH):
self.update_controller()
self.root.after(round(self.UI_REFRESH * 1000.0), self.update_interface)
class MarkovDemo:
def __init__(self, master):
self.prompt_size = Label(master, anchor=W, text='Encode Word Size')
self.prompt_size.pack(side=TOP, fill=X)
self.size_entry = Entry(master)
self.size_entry.insert(0, '8')
self.size_entry.pack(fill=X)
self.prompt_plain = Label(master, anchor=W, text='Plaintext Characters')
self.prompt_plain.pack(side=TOP, fill=X)
self.plain_entry = Entry(master)
self.plain_entry.insert(0, '""')
self.plain_entry.pack(fill=X)
self.showframe = Frame(master)
self.showframe.pack(fill=X, anchor=W)
self.showvar = StringVar(master)
self.showvar.set("encode")
self.showfirstradio = Radiobutton(self.showframe,
text="Encode Plaintext",
variable=self.showvar,
value="encode",
command=self.reevaluate)
self.showfirstradio.pack(side=LEFT)
self.showallradio = Radiobutton(self.showframe,
text="Decode Cyphertext",
variable=self.showvar,
value="decode",
command=self.reevaluate)
self.showallradio.pack(side=LEFT)
self.inputbox = ScrolledText(master, width=60, height=10, wrap=WORD)
self.inputbox.pack(fill=BOTH, expand=1)
self.dynamic_var = IntVar()
self.dynamic_box = Checkbutton(master, variable=self.dynamic_var,
text='Dynamic Evaluation',
offvalue=False, onvalue=True,
command=self.reevaluate)
self.dynamic_box.pack()
self.output = Label(master, anchor=W, text="This is your output:")
self.output.pack(fill=X)
self.outbox = ScrolledText(master, width=60, height=10, wrap=WORD)
self.outbox.pack(fill=BOTH, expand=1)
self.inputbox.bind('<Key>', self.reevaluate)
def select_all(event=None):
event.widget.tag_add(SEL, 1.0, 'end-1c')
event.widget.mark_set(INSERT, 1.0)
event.widget.see(INSERT)
return 'break'
self.inputbox.bind('<Control-Key-a>', select_all)
self.outbox.bind('<Control-Key-a>', select_all)
self.inputbox.bind('<Control-Key-/>', lambda event: 'break')
self.outbox.bind('<Control-Key-/>', lambda event: 'break')
self.outbox.config(state=DISABLED)
def reevaluate(self, event=None):
if event is not None:
if event.char == '':
return
if self.dynamic_var.get():
text = self.inputbox.get(1.0, END)[:-1]
if len(text) < 10:
return
text = text.replace('\n \n', '\n\n')
mode = self.showvar.get()
assert mode in ('decode', 'encode'), 'Bad mode!'
if mode == 'encode':
# Encode Plaintext
try:
# Evaluate the plaintext characters
plain = self.plain_entry.get()
if plain:
PC = eval(self.plain_entry.get())
else:
PC = ''
self.plain_entry.delete(0, END)
self.plain_entry.insert(0, '""')
# Evaluate the word size
size = self.size_entry.get()
if size:
XD = int(size)
while grid_size(text, XD, PC) > 1 << 20:
XD -= 1
else:
XD = 0
grid = 0
while grid <= 1 << 20:
grid = grid_size(text, XD, PC)
XD += 1
XD -= 1
# Correct the size and encode
self.size_entry.delete(0, END)
self.size_entry.insert(0, str(XD))
cyphertext, key, prime = encrypt_str(text, XD, PC)
except:
traceback.print_exc()
else:
buffer = ''
for block in key:
buffer += repr(block)[2:-1] + '\n'
buffer += repr(prime)[2:-1] + '\n\n' + cyphertext
self.outbox.config(state=NORMAL)
self.outbox.delete(1.0, END)
self.outbox.insert(END, buffer)
self.outbox.config(state=DISABLED)
else:
# Decode Cyphertext
try:
header, cypher = text.split('\n\n', 1)
lines = header.split('\n')
for index, item in enumerate(lines):
try:
lines[index] = eval('b"' + item + '"')
except:
lines[index] = eval("b'" + item + "'")
plain = decrypt_str(cypher, tuple(lines[:-1]), lines[-1])
except:
traceback.print_exc()
else:
self.outbox.config(state=NORMAL)
self.outbox.delete(1.0, END)
self.outbox.insert(END, plain)
self.outbox.config(state=DISABLED)
else:
text = self.inputbox.get(1.0, END)[:-1]
text = text.replace('\n \n', '\n\n')
mode = self.showvar.get()
assert mode in ('decode', 'encode'), 'Bad mode!'
if mode == 'encode':
try:
XD = int(self.size_entry.get())
PC = eval(self.plain_entry.get())
size = grid_size(text, XD, PC)
assert size
except:
pass
else:
buffer = 'Grid size will be:\n' + convert(size)
self.outbox.config(state=NORMAL)
self.outbox.delete(1.0, END)
self.outbox.insert(END, buffer)
self.outbox.config(state=DISABLED)
class Rest(ttk.Frame):
GET = 'GET'
POST = 'POST'
PUT = 'PUT'
DELETE = 'DELETE'
OPTIONS = 'OPTIONS'
TRACE = 'TRACE'
HEAD = 'HEAD'
def __init__(self, root, *args, **kwargs):
super(Rest, self).__init__(*args, **kwargs)
self.pack()
menubar = tkinter.Menu(root)
menu_arquivo = tkinter.Menu(menubar, tearoff=0)
menubar.add_cascade(label="Arquivo", menu=menu_arquivo)
menu_arquivo.add_command(label="Novo", command=self.novo_arquivo)
menu_arquivo.add_command(label="Abrir", command=self.abrir_arquivo)
menu_arquivo.add_command(label="Salvar", command=self.salvar_arquivo)
menu_arquivo.add_command(label="Sair",command=root.quit)
root.config(menu=menubar)
self.url = tkinter.StringVar()
self.frame_url = ttk.Frame(self)
self.frame_url.pack()
self.lbl_url_entry = tkinter.Label(self.frame_url,text='URL')
self.lbl_url_entry.pack(side=tkinter.LEFT)
self.url_entry = tkinter.Entry(self.frame_url,textvariable=self.url, width=80)
self.url_entry.pack(side=tkinter.LEFT)
self.metodo = tkinter.StringVar()
self.metodos_combo = ttk.Combobox(self.frame_url, textvariable=self.metodo, width=8)
self.metodos_combo.bind("<<ComboboxSelected>>", self.metodo_select)
self.metodos_combo['values'] = (Rest.GET, Rest.POST,Rest.PUT, Rest.DELETE, Rest.OPTIONS, Rest.TRACE, Rest.HEAD)
self.metodos_combo.pack(side=tkinter.LEFT)
self.metodos_combo.state(['readonly'])
self.metodo.set( self.metodos_combo['values'][0] )
self.botao_ir = ttk.Button( self.frame_url, text='IR', command=self.request)
self.botao_ir.pack(side=tkinter.LEFT)
self.frame_header = ttk.Frame(self)
self.frame_header.pack(fill=tkinter.X, padx=5, pady=2)
self.lbl_headers = tkinter.Label(self.frame_header,text='Headers')
self.lbl_headers.pack(side=tkinter.LEFT)
self.botao_addheader = ttk.Button( self.frame_header, text='+', command=self.add_header)
self.botao_addheader.pack(side=tkinter.RIGHT)
self.headers_canvas = tkinter.Canvas(self, borderwidth=0, height=100)
self.frame_headers = ttk.Frame(self.headers_canvas)
self.frame_headers.pack()
#Scrollbar
self.scroll_bar_y = tkinter.Scrollbar(self, orient=tkinter.VERTICAL, command=self.headers_canvas.yview)
self.headers_canvas.configure(yscrollcommand=self.scroll_bar_y.set)
self.scroll_bar_y.pack(side=tkinter.RIGHT, fill=tkinter.Y)
self.scroll_bar_x = tkinter.Scrollbar(self, orient=tkinter.HORIZONTAL, command=self.headers_canvas.xview)
self.headers_canvas.configure(xscrollcommand=self.scroll_bar_x.set)
self.scroll_bar_x.pack(side=tkinter.BOTTOM, fill=tkinter.X)
self.headers_canvas.pack(side=tkinter.LEFT, fill=tkinter.BOTH, expand=True)
self.headers_canvas.create_window((1,1), window=self.frame_headers, anchor="nw", tags="self.frame_headers")
self.frame_headers.bind("<Configure>", self.on_frame_configure)
self.lista_headers = []
frame_keyvalue = tkinter.Frame(self.frame_headers)
frame_keyvalue.pack()
header1 = tkinter.Label(frame_keyvalue, text='Header')
header1.pack(side=tkinter.LEFT)
value_header1 = tkinter.Label(frame_keyvalue, text='Valor')
value_header1.pack(side=tkinter.LEFT)
lbl_body = tkinter.Label(root, text='Body')
lbl_body.pack()
self.body = ScrolledText(root, height=10, width=100)
self.body.pack()
lbl_retorno = tkinter.Label(root, text='Retorno')
lbl_retorno.pack()
self.retorno = ScrolledText(root, height=18, width=100)
self.retorno.pack()
self.metodo_select()#Bloqueando o Body para edição
self.lbl_request = tkinter.Label(root,text='')
self.lbl_request.pack()
def metodo_select(self, value=None):
metodo = self.metodo.get()
if metodo == Rest.POST or metodo == Rest.PUT:
self.body.config(state=tkinter.NORMAL)
elif metodo == Rest.GET or metodo == Rest.DELETE:
self.body.config(state=tkinter.DISABLED)
def remove_header(self, chave, frame):
for item in self.lista_headers:
if item[0] == chave:
self.lista_headers.remove(item)
frame.destroy()
def add_header(self, key='', value=''):
chave = tkinter.StringVar()
chave.set(key)
valor = tkinter.StringVar()
valor.set(value)
frame_keyvalue = tkinter.Frame(self.frame_headers)
frame_keyvalue.pack()
header1 = tkinter.Entry(frame_keyvalue,textvariable=chave)
header1.pack(side=tkinter.LEFT)
value_header1 = tkinter.Entry(frame_keyvalue,textvariable=valor)
value_header1.pack(side=tkinter.LEFT)
botao_remover = tkinter.Button(frame_keyvalue, text='-',command=lambda: self.remove_header(chave, frame_keyvalue))
botao_remover.pack(side=tkinter.LEFT)
self.lista_headers.append( (chave, valor, frame_keyvalue) )
def on_frame_configure(self, event):
'''Reset the scroll region to encompass the inner frame'''
self.headers_canvas.configure(scrollregion=self.headers_canvas.bbox("all"))
def get_headers(self):
headers = {}
for keyValue in self.lista_headers:
headers[ keyValue[0].get() ] = keyValue[1].get()
return headers
def get_data(self):
return self.body.get(0.0,tkinter.END)
def request(self):
resposta = ''
try:
metodo = self.metodo.get()
headers = self.get_headers()
if metodo == Rest.POST:
data = self.get_data()
resposta = r.post(self.url.get(), headers=headers, data=data)
elif metodo == Rest.GET:
resposta = r.get(self.url.get(), headers=headers)
elif metodo == Rest.PUT:
data = self.get_data()
resposta = r.put(self.url.get(), headers=headers, data=data)
elif metodo == Rest.DELETE:
resposta = r.delete(self.url.get(), headers=headers)
elif metodo == Rest.OPTIONS:
resposta = r.options(self.url.get(), headers=headers)
elif metodo == Rest.TRACE:
resposta = r.trace(self.url.get(), headers=headers)
elif metodo == Rest.HEAD:
resposta = r.head(self.url.get(), headers=headers)
except Exception as ex:
print(ex)
resposta = ex.message
self.tratar_resposta(resposta)
self.retorno.delete(0.0,tkinter.END)
try:
load = json.loads(resposta.text)
self.retorno.insert(tkinter.END, json.dumps(load, indent=4, sort_keys=True) )
except:
soup = BeautifulSoup(resposta.text)
self.retorno.insert(tkinter.END, soup.prettify() )
def tratar_resposta(self, resposta):
try:
texto = 'Status: {0}\n'.format(resposta.status_code)
texto += 'Headers:\n'
for key in resposta.headers.keys():
texto += '\t {0}:{1}\n'.format(key, resposta.headers[key])
texto += 'Encoding:{0}\n'.format(resposta.encoding)
self.lbl_request['text'] = texto
except Exception as ex:
print(ex)
self.lbl_request['text'] = 'Erro'
def abrir_arquivo(self):
arquivo = askopenfilename(title='Escolher arquivo',filetypes=( ("JSON File", "*.json"), ) )
if arquivo:
self.novo_arquivo() # Limpa os campos
arquivo_json = None
with open(arquivo, 'r') as configuracao:
arquivo_json = configuracao.read()
arquivo_json = json.loads(arquivo_json)
self.url.set( arquivo_json['url'] )
if arquivo_json['method']:
if arquivo_json['method'] == Rest.GET:
self.metodo.set( Rest.GET )
elif arquivo_json['method'] == Rest.POST:
self.metodo.set( Rest.POST )
elif arquivo_json['method'] == Rest.PUT:
self.metodo.set( Rest.PUT )
elif arquivo_json['method'] == Rest.DELETE:
self.metodo.set( Rest.DELETE )
elif arquivo_json['method'] == Rest.OPTIONS:
self.metodo.set( Rest.OPTIONS )
elif arquivo_json['method'] == Rest.TRACE:
self.metodo.set( Rest.TRACE )
elif arquivo_json['method'] == Rest.HEAD:
self.metodo.set( Rest.HEAD )
self.metodo_select()
if arquivo_json['data']:
self.body.delete(0.0,tkinter.END)
self.body.insert(tkinter.END, arquivo_json['data'])
if 'headers' in arquivo_json:
for key in arquivo_json['headers'].keys():
self.add_header(key=key, value=arquivo_json['headers'][key])
def novo_arquivo(self):
self.url.set('')
self.body.delete(0.0,tkinter.END)
self.retorno.delete(0.0,tkinter.END)
self.lbl_request['text'] = ''
self.metodo.set( Rest.GET )
while True:
if self.lista_headers:
item = self.lista_headers[0]
key = item[0]
frame = item[2]
self.remove_header( key, frame )
else:
break
def salvar_arquivo(self):
arquivo_destino = asksaveasfilename(title='Salvar JSON do Request', filetypes=[('JSON File','*.json')])
if arquivo_destino:
dicionario = {}
dicionario['headers'] = self.get_headers()
dicionario['data'] = self.get_data()
dicionario['method'] = self.metodo.get()
dicionario['url'] = self.url.get()
with open(arquivo_destino, 'w') as destino:
destino.write( json.dumps(dicionario) )
messagebox.showinfo('Rest', 'Arquivos salvo com sucesso')
class Editor(Tk):
def __init__(self, fname, *args, **kwargs): # This is a tangled mess. I am sorry.
Tk.__init__(self, *args, **kwargs)
for x in range(1):
Grid.columnconfigure(self, x, weight=1)
Grid.rowconfigure(self, x, weight=1)
self.fname = fname
self.opened = None
self.tree = ttk.Treeview(self)
self.ysb = ttk.Scrollbar(self, orient='vertical', command=self.tree.yview)
self.tree.configure(yscroll=self.ysb.set)
self.tree.heading('#0', text='Path', anchor='w')
self.data = classes.Folder()
self.data.load(open(self.fname).read())
self.iidmap = {}
self.root_node = self.tree.insert('', 'end', text='/', open=True)
self.updatetree()
self.st = ScrolledText()
self.st.grid(row=1, column=1, sticky=N+E+S+W)
self.meta = Frame()
self.namel = Label(self.meta)
self.namee = Entry(self.meta)
self.namel.grid(row=0, column=0)
self.namee.grid(row=0, column=1)
self.tree.grid(rowspan=2, row=0, column=0, sticky=N+S+E+W)
self.meta.grid(row=2, column=1)
self.bind('<Control-s>', self.save)
self.mb = Menu()
self.fm = Menu()
self.fm.add_command(label='Save', accelerator='Ctrl+S', command=self.save)
self.mb.add_cascade(menu=self.fm, label='Savefile')
self.dm = Menu()
self.dm.add_command(label='New file', command=self.newfile)
self.mb.add_cascade(menu=self.dm, label='Files')
self.config(menu=self.mb)
def loadf(self, event=None):
self.st.delete(1.0, END)
self.namee.delete(0, END)
if self.data[self.opened]:
self.st.insert(1.0, self.data[self.opened].content)
self.namee.insert(1, self.data[self.opened].name)
def updatetree(self):
self.tree.delete(self.root_node)
self.root_node = self.tree.insert('', 'end', text='/', open=True)
for f in self.data:
item = self.tree.insert(self.root_node, 'end', text=f, open=False)
self.iidmap[item] = f
self.tree.bind('<Double-1>', self.openitem)
def openitem(self, event=None):
item = self.tree.identify('item', event.x, event.y)
if item:
self.opened = self.iidmap[item]
self.loadf()
def save(self, event=None):
self.update_fs()
open(self.fname, 'w').write(json.dumps(self.data.dump()))
def update_fs(self, event=None):
self.data[self.opened].write(self.st.get(1.0, END))
self.data[self.opened].rename(self.namee.get())
def newfile(self, event=None):
name = input('Filename: ')
self.opened = name
self.data.create_file(name)
self.updatetree()
class Application(tkinter.Tk):
def __init__(self):
"""Initialize widgets, methods."""
tkinter.Tk.__init__(self)
self.grid()
fontoptions = families(self)
font = Font(family="Verdana", size=10)
menubar = tkinter.Menu(self)
fileMenu = tkinter.Menu(menubar, tearoff=0)
editMenu = tkinter.Menu(menubar, tearoff=0)
fsubmenu = tkinter.Menu(editMenu, tearoff=0)
ssubmenu = tkinter.Menu(editMenu, tearoff=0)
# adds fonts to the font submenu and associates lambda functions
for option in fontoptions:
fsubmenu.add_command(label=option, command = lambda: font.configure(family=option))
# adds values to the size submenu and associates lambda functions
for value in range(1,31):
ssubmenu.add_command(label=str(value), command = lambda: font.configure(size=value))
# adds commands to the menus
menubar.add_cascade(label="File",underline=0, menu=fileMenu)
menubar.add_cascade(label="Edit",underline=0, menu=editMenu)
fileMenu.add_command(label="New", underline=1,
command=self.new, accelerator="Ctrl+N")
fileMenu.add_command(label="Open", command=self.open, accelerator="Ctrl+O")
fileMenu.add_command(label="Save", command=self.save, accelerator="Ctrl+S")
fileMenu.add_command(label="Exit", underline=1,
command=exit, accelerator="Ctrl+Q")
editMenu.add_command(label="Copy", command=self.copy, accelerator="Ctrl+C")
editMenu.add_command(label="Cut", command=self.cut, accelerator="Ctrl+X")
editMenu.add_command(label="Paste", command=self.paste, accelerator="Ctrl+V")
editMenu.add_cascade(label="Font", underline=0, menu=fsubmenu)
editMenu.add_cascade(label="Size", underline=0, menu=ssubmenu)
editMenu.add_command(label="Color", command=self.color)
editMenu.add_command(label="Bold", command=self.bold, accelerator="Ctrl+B")
editMenu.add_command(label="Italic", command=self.italic, accelerator="Ctrl+I")
editMenu.add_command(label="Underline", command=self.underline, accelerator="Ctrl+U")
editMenu.add_command(label="Overstrike", command=self.overstrike, accelerator="Ctrl+T")
editMenu.add_command(label="Undo", command=self.undo, accelerator="Ctrl+Z")
editMenu.add_command(label="Redo", command=self.redo, accelerator="Ctrl+Y")
self.config(menu=menubar)
"""Accelerator bindings. The cut, copy, and paste functions are not
bound to keyboard shortcuts because Windows already binds them, so if
Tkinter bound them as well whenever you typed ctrl+v the text would be
pasted twice."""
self.bind_all("<Control-n>", self.new)
self.bind_all("<Control-o>", self.open)
self.bind_all("<Control-s>", self.save)
self.bind_all("<Control-q>", self.exit)
self.bind_all("<Control-b>", self.bold)
self.bind_all("<Control-i>", self.italic)
self.bind_all("<Control-u>", self.underline)
self.bind_all("<Control-T>", self.overstrike)
self.bind_all("<Control-z>", self.undo)
self.bind_all("<Control-y>", self.redo)
self.text = ScrolledText(self, state='normal', height=30, wrap='word', font = font, pady=2, padx=3, undo=True)
self.text.grid(column=0, row=0, sticky='NSEW')
# Frame configuration
self.grid_columnconfigure(0, weight=1)
self.resizable(True, True)
"""Command functions. *args is included because the keyboard bindings pass
two arguments to the functions, while clicking in the menu passes only 1."""
def new(self, *args):
"""Creates a new window."""
app = Application()
app.title('Python Text Editor')
app.option_add('*tearOff', False)
app.mainloop()
def color(self):
"""Changes selected text color."""
try:
(rgb, hx) = tkinter.colorchooser.askcolor()
self.text.tag_add('color', 'sel.first', 'sel.last')
self.text.tag_configure('color', foreground=hx)
except TclError:
pass
def bold(self, *args):
"""Toggles bold for selected text."""
try:
current_tags = self.text.tag_names("sel.first")
if "bold" in current_tags:
self.text.tag_remove("bold", "sel.first", "sel.last")
else:
self.text.tag_add("bold", "sel.first", "sel.last")
bold_font = Font(self.text, self.text.cget("font"))
bold_font.configure(weight="bold")
self.text.tag_configure("bold", font=bold_font)
except TclError:
pass
def italic(self, *args):
"""Toggles italic for selected text."""
try:
current_tags = self.text.tag_names("sel.first")
if "italic" in current_tags:
self.text.tag_remove("italic", "sel.first", "sel.last")
else:
self.text.tag_add("italic", "sel.first", "sel.last")
italic_font = Font(self.text, self.text.cget("font"))
italic_font.configure(slant="italic")
self.text.tag_configure("italic", font=italic_font)
except TclError:
pass
def underline(self, *args):
"""Toggles underline for selected text."""
try:
current_tags = self.text.tag_names("sel.first")
if "underline" in current_tags:
self.text.tag_remove("underline", "sel.first", "sel.last")
else:
self.text.tag_add("underline", "sel.first", "sel.last")
underline_font = Font(self.text, self.text.cget("font"))
underline_font.configure(underline=1)
self.text.tag_configure("underline", font=underline_font)
except TclError:
pass
def overstrike(self, *args):
"""Toggles overstrike for selected text."""
try:
current_tags = self.text.tag_names("sel.first")
if "overstrike" in current_tags:
self.text.tag_remove("overstrike", "sel.first", "sel.last")
else:
self.text.tag_add("overstrike", "sel.first", "sel.last")
overstrike_font = Font(self.text, self.text.cget("font"))
overstrike_font.configure(overstrike=1)
self.text.tag_configure("overstrike", font=overstrike_font)
except TclError:
pass
def undo(self, *args):
"""Undo function"""
try:
self.text.edit_undo()
except TclError:
pass
def redo(self, *args):
"""Redo function"""
try:
self.text.edit_redo()
except TclError:
pass
def copy(self, *args):
"""Copy text"""
self.clipboard_clear()
self.clipboard_append(self.text.selection_get())
def cut(self, *args):
"""Cut text"""
self.copy
self.text.delete("sel.first", "sel.last")
def paste(self, *args):
"""Paste text"""
insertion = self.selection_get(selection = "CLIPBOARD")
self.text.insert(0.0, insertion)
def open(self, *args):
"""Opens a file dialog to open a plain text file."""
filename = tkinter.filedialog.askopenfilename()
with open(filename) as f:
text = f.read()
self.text.delete("1.0", "end")
self.text.insert('insert', text)
def save(self, *args):
try:
"""Opens a file dialog to save the text in plain text format."""
text = self.text.get("1.0", "end")
filename = tkinter.filedialog.asksaveasfilename()
with open(filename, 'w') as f:
f.write(text)
except FileNotFoundError:
pass
def exit(self, *args):
"""Exits the program."""
self.quit()
class MarkovDemo(Frame):
"MarkovDemo(master=None, **kw) -> MarkovDemo instance"
TEXT = dict(height=2, width=46, wrap=WORD) # Text Options
GRID = dict(padx=5, pady=5) # Grid Options
# Initialize a MarkovDemo instance with a GUI for interaction.
def __init__(self, master=None, **kw):
"Initialize the MarkovDemo instance's widgets and settings."
super().__init__(master, **kw)
self.build_widgets()
self.place_widgets()
self.setup_widgets()
self.grid_rowconfigure(2, weight=1)
self.grid_rowconfigure(3, weight=1)
self.grid_columnconfigure(0, weight=1)
self.key = self.primer = None
def build_widgets(self):
"Build the various widgets that will be used in the program."
# Create processing frame widgets.
self.processing_frame = LabelFrame(self, text='Processing Mode:')
self.mode_var = StringVar(self, 'encode')
self.decode_button = Radiobutton(self.processing_frame,
text='Decode Cipher-Text',
command=self.handle_radiobuttons,
value='decode',
variable=self.mode_var)
self.encode_button = Radiobutton(self.processing_frame,
text='Encode Plain-Text',
command=self.handle_radiobuttons,
value='encode',
variable=self.mode_var)
self.freeze_var = BooleanVar(self, False)
self.freeze_button = Checkbutton(self.processing_frame,
text='Freeze Key & Primer',
command=self.handle_checkbutton,
offvalue=False,
onvalue=True,
variable=self.freeze_var)
# Create encoding frame widgets.
self.encoding_frame = LabelFrame(self, text='Encoding Options:')
self.chain_size_label = Label(self.encoding_frame, text='Chain Size:')
self.chain_size_entry = Entry(self.encoding_frame)
self.plain_text_label = Label(self.encoding_frame, text='Plain-Text:')
self.plain_text_entry = Entry(self.encoding_frame)
# Create input frame widgets.
self.input_frame = LabelFrame(self, text='Input Area:')
self.input_text = ScrolledText(self.input_frame, **self.TEXT)
# Create output frame widgets.
self.output_frame = LabelFrame(self, text='Output Area:')
self.output_text = ScrolledText(self.output_frame, **self.TEXT)
def place_widgets(self):
"Place the widgets where they belong in the MarkovDemo frame."
# Locate processing frame widgets.
self.processing_frame.grid(sticky=EW, **self.GRID)
self.decode_button.grid(row=0, column=0, **self.GRID)
self.encode_button.grid(row=0, column=1, **self.GRID)
self.freeze_button.grid(row=0, column=2, **self.GRID)
# Locate encoding frame widgets.
self.encoding_frame.grid(sticky=EW, **self.GRID)
self.chain_size_label.grid(row=0, column=0, sticky=W, **self.GRID)
self.chain_size_entry.grid(row=0, column=1, sticky=EW, **self.GRID)
self.plain_text_label.grid(row=1, column=0, sticky=W, **self.GRID)
self.plain_text_entry.grid(row=1, column=1, sticky=EW, **self.GRID)
self.encoding_frame.grid_columnconfigure(1, weight=1)
# Locate input frame widgets.
self.input_frame.grid(sticky=NSEW, **self.GRID)
self.input_text.grid(sticky=NSEW, **self.GRID)
self.input_frame.grid_rowconfigure(0, weight=1)
self.input_frame.grid_columnconfigure(0, weight=1)
# Locate output frame widgets.
self.output_frame.grid(sticky=NSEW, **self.GRID)
self.output_text.grid(sticky=NSEW, **self.GRID)
self.output_frame.grid_rowconfigure(0, weight=1)
self.output_frame.grid_columnconfigure(0, weight=1)
def setup_widgets(self):
"Setup each widget's configuration for the events they handle."
self.input_text.bind('<Key>', self.handle_key_events)
self.input_text.bind('<Control-Key-a>', self.handle_control_a)
self.input_text.bind('<Control-Key-/>', lambda event: 'break')
self.output_text['state'] = DISABLED
self.output_text.bind('<Control-Key-a>', self.handle_control_a)
self.output_text.bind('<Control-Key-/>', lambda event: 'break')
########################################################################
# Take care of any special event needing dedicated processing.
def handle_radiobuttons(self):
"Change the interface based on the encoding / decoding setting."
if self.encrypting:
self.freeze_button.grid()
if not self.freeze_var.get():
self.encoding_frame.grid()
else:
self.freeze_button.grid_remove()
if not self.freeze_var.get():
self.encoding_frame.grid_remove()
self.handle_key_events(None)
def handle_checkbutton(self):
"Change the interface based on the key / primer freeze setting."
if self.freeze_var.get():
self.encoding_frame.grid_remove()
else:
self.encoding_frame.grid()
def handle_key_events(self, event):
"Schedule refreshing the output area after an input area event."
if event is None or event.char and event.state | 0o11 == 0o11:
self.after_idle(self.refresh)
@staticmethod
def handle_control_a(event):
"Select all text in the widget associated with the given event."
event.widget.tag_add(SEL, 1.0, END + '-1c')
return 'break'
########################################################################
# Handle interface's updates when either encoding or decoding.
def refresh(self):
"Refresh the output based on the value of the input."
text = self.input_text.get(1.0, END + '-1c')
if not text:
self.output = text
elif self.encrypting:
self.encode(text)
else:
self.decode(text)
def output(self, value):
"Set the text in the output area to the string value."
self.output_text['state'] = NORMAL
self.output_text.delete(1.0, END)
self.output_text.insert(END, value)
if self.encrypting and self.freeze_var.get():
self.output_text.see(END)
self.output_text['state'] = DISABLED
output = property(fset=output, doc='Output area property.')
@property
def chain_size(self):
"Chain size for the Markov chains used when encrypting."
try:
value = ast.literal_eval(self.chain_size_entry.get())
assert isinstance(value, int) and 2 <= value <= 256
return value
except:
self.chain_size_entry.delete(0, END)
self.chain_size_entry.insert(0, '2')
return 2
@property
def plain_text(self):
"Plain text or ignored characters in encryption process."
try:
value = self.repr_to_obj(self.plain_text_entry.get(), '')
assert isinstance(value, str)
return value
except:
self.plain_text_entry.delete(0, END)
return ''
########################################################################
# Encrypt a string for display in the interface's output area.
def encode(self, string):
"Encode the string and show the cipher-text in the output."
try:
cipher = self.build_cipher(string)
except ValueError:
self.output = ''
except:
self.output = traceback.format_exc()
else:
self.output = self.build_header() + '\n\n' + cipher
def build_cipher(self, string):
"Build cipher-text based on plain-text and return answer."
if self.key and self.freeze_var.get():
cipher, primer = me.encrypt_str(string, self.key, self.primer)
else:
args = string, self.chain_size, self.plain_text
cipher, self.key, self.primer = me.auto_encrypt_str(*args)
return cipher
def build_header(self):
"Build header from key and primer values in current use."
header = '\n'.join(map(self.bytes_to_repr, self.key.data))
header += '\n' + self.bytes_to_repr(self.primer.data)
return header
########################################################################
# Decrypt a string for display in the interface's output area.
def decode(self, string):
"Decode encrypted message and display plain-text in output."
try:
cipher = self.extract_keys(string)
text = self.extract_text(cipher)
except ValueError:
self.output = ''
except:
self.output = traceback.format_exc()
else:
self.output = text
def extract_keys(self, string):
"Extract keys to decryption and return the cipher-text area."
header, cipher = string.split('\n\n', 1)
*key, primer = map(self.repr_to_obj, header.split('\n'))
self.key, self.primer = me.Key(tuple(key)), me.Primer(primer)
return cipher
def extract_text(self, string):
"Extract text message from string using built key and primer."
text, primer = me.decrypt_str(string, self.key, self.primer)
return text
########################################################################
# Provide some special methods to simplify the program's code.
@property
def encrypting(self):
"Encrypting boolean stating current operations mode."
return {'encode': True, 'decode': False}[self.mode_var.get()]
@staticmethod
def bytes_to_repr(obj):
"Convert bytes object into suitable representation."
if not isinstance(obj, bytes):
raise TypeError('Object must be a bytes instance!')
return repr(obj)[2:-1]
@staticmethod
def repr_to_obj(string, prefix='b'):
"Convert representation into an equivalent object."
for template in '{}"{}"', "{}'{}'":
try:
return ast.literal_eval(template.format(prefix, string))
except:
pass
raise ValueError('Cannot convert {!r} to object!'.format(string))
@classmethod
def main(cls):
"Create context for demo and run a test instance."
NoDefaultRoot()
root = Tk()
root.minsize(420, 330)
root.title('Markov Demo 2')
test = cls(root)
test.grid(sticky=NSEW)
root.grid_rowconfigure(0, weight=1)
root.grid_columnconfigure(0, weight=1)
root.mainloop()
