def __init__(self, master):
# Prevent the app window from being resized
master.resizable(False, False)
self.banner = Banner(master)
self.content = Content(master)
# KEYBOARD SHORTCUTS SECTION
master.bind('<Control-n>', lambda e: self.content.add_task())
# MENU BAR SECTION
master.option_add('*tearOff', False)
self.menubar = Menu(master)
master.config(menu=self.menubar)
# FILE MENU
file = Menu(self.menubar)
file.add_command(label='Test',
command=lambda: messagebox.showinfo(
title='Test', message='This is a test.'))
file.add_command(label='Add Task',
command=lambda: self.content.add_task())
file.entryconfig('Add Task', accelerator='CTRL+N')
self.menubar.add_cascade(menu=file, label='File')
# EDIT MENU
edit = Menu(self.menubar)
edit.add_command(label='Change Banner Color',
command=lambda: self.banner.change_banner_color())
self.menubar.add_cascade(menu=edit, label='Edit')
class SQLiteReader(Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.master.option_add('*tearOff', False)
self.master.title('SQLite Reader')
self.master.geometry('800x400+10+10')
self.grid(column=0, row=0, sticky=(N, W, E, S))
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(0, weight=1)
self.create_menu()
self.create_widget()
self.tabs = []
def create_widget(self):
self.tab_parent = Notebook(self)
self.tab_parent.grid(column=0, row=0, sticky=(N, W, S, E))
def create_menu(self):
self._menu = Menu(self.master)
self.master.config(menu=self._menu)
self.file_menu = Menu(self._menu)
self.file_menu.add_command(label='Open', command=self.open_database)
self.file_menu.add_command(label='Query', command=self.run_query, state='disabled')
self._menu.add_cascade(label='File', menu=self.file_menu)
self._menu.add_command(label='Reload', command=self.reload_current_table, state='disabled')
self._menu.add_command(label='Exit', command=self.master.destroy)
def open_database(self, new_folder=True):
for item in self.tab_parent.winfo_children():
item.destroy()
if new_folder:
self.file_name = filedialog.askopenfilename()
self.db = SQLiteConnector(self.file_name)
for idx, table in enumerate(self.db.tables):
new_tab = SQLTableFrame(self.tab_parent, table, self.db)
self.tab_parent.add(new_tab, text=table)
self.tab_query = SQLTableFrameQuery(self.tab_parent)
self.tab_parent.add(self.tab_query, text='queries')
self._menu.entryconfig('Reload', state='normal')
self.file_menu.entryconfig('Query', state='normal')
def reload_current_table(self):
if hasattr(self, 'query_window'):
self.query_window.destroy()
self.open_database(new_folder=False)
def run_query(self):
self.tab_parent.select(self.tab_query)
self.query_window = SQLQueryWindow(self.master, db=self.db, query_tab=self.tab_query)
def editMenu(self):
"""
Builds the editmenu
"""
pulldown = Menu(self.menubar)
pulldown.add_command(label='Paste', command=self.notdone)
pulldown.add_command(label='Spam', command=self.greeting)
pulldown.add_separator()
pulldown.add_command(label='Delete', command=self.greeting)
pulldown.entryconfig(4, state=DISABLED)
self.menubar.add_cascade(label='Edit', underline=0, menu=pulldown)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.root = self.winfo_toplevel()
self.root.option_add("*Font", "serif 10 bold")
self.root.title(" ".join((APPNAME, VERSION, "| Main")))
self.root.resizable(0,0)
self.root.bind('<Key>', self.__keys)
# Menu
menubar = Menu(self.root)
self.windowsmenu = Menu(menubar, tearoff=0)
self.windowsmenu.add_command(label="[ ] Report window", command=self.__toggle_report)
self.windowsmenu.add_command(label="Plot current model", command=self.__plot)
self.windowsmenu.add_separator()
self.windowsmenu.add_command(label="Quit", command=self.destroy)
menubar.add_cascade(label="Windows", menu=self.windowsmenu)
settingsmenu = Menu(menubar, tearoff=0)
settingsmenu.add_command(label="Spectrum range")
settingsmenu.add_command(label="Color scheme")
menubar.add_cascade(label="Settings", menu=settingsmenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="Help", command=self.__help)
helpmenu.add_separator()
helpmenu.add_command(label="About", command=self.__about)
menubar.add_cascade(label="Help", menu=helpmenu)
self.root.config(menu=menubar)
# disabled menu items
settingsmenu.entryconfig(0, state='disabled')
settingsmenu.entryconfig(1, state='disabled')
helpmenu.entryconfig(0, state='disabled')
# Scale
ctrls = Labelframe(self, text='Control', relief='ridge')
self.e = Scale(ctrls, from_=E_MIN, to=E_MAX, label='Links',
bd=1, width=7, length=150, orient='horizontal')
self.d = Scale(ctrls, from_=D_MIN, to=D_MAX, label='Pages',
bd=1, width=7, length=150, orient='horizontal')
self.e.set(E)
self.d.set(D)
self.e.config(command=self.__refresh)
self.d.config(command=self.__refresh)
self.e.pack(side='left')
self.d.pack(side='right')
self.r_win = False
ctrls.pack(side='top', anchor='e', padx=7, pady=5)
# initialize model
self.generate_model()
self.c = GraphViewer(self, D, self.edge_counts, self.pagerank)
self.c.pack()
# open windows
self.__toggle_report()
class Popup:
def __init__(self, main):
self.main = main
self.menu = Menu(main, tearoff=0)
self.menu.add_command(label="Remove")
main.tree.bind("<Button-3>", self.show)
def show(self, event):
iid = self.main.tree.identify_row(event.y)
if iid:
self.menu.tk_popup(event.x_root, event.y_root, 0)
self.menu.entryconfig("Remove",
command=lambda: self.main.remove_tag(iid))
def create_tools_menu_fields(self, menubar):
'''Creates "tools" menu fields.
Parameters
----------
menubar : object
tkinter menu object
'''
toolsmenu = Menu(menubar, tearoff=0)
toolsmenu.add_command(label='Finder', command=self.open_finder)
toolsmenu.entryconfig('Finder', accelerator='Ctrl+F')
self.master.bind('<Control-f>', self.open_finder)
menubar.add_cascade(label='Tools', menu=toolsmenu)
def create_file_menu_fields(self, menubar):
'''Creates "file" menu fields.
Parameters
----------
menubar : object
tkinter menu object
'''
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='New', command=self.new_file)
filemenu.entryconfig('New', accelerator='Ctrl+N')
self.master.bind('<Control-n>', self.new_file)
filemenu.add_command(label='Open', command=self.open_file)
filemenu.entryconfig('Open', accelerator='Ctrl+O')
self.master.bind('<Control-o>', self.open_file)
filemenu.add_command(label='Save', command=self.save_file)
filemenu.entryconfig('Save', accelerator='Ctrl+S')
self.master.bind('<Control-s>', self.save_file)
filemenu.add_command(label='Save As', command=self.save_as_file)
filemenu.add_separator()
filemenu.add_command(label='Exit', command=self.exit_app)
menubar.add_cascade(label='File', menu=filemenu)
class MenuGui:
def __init__(self, main_controller, window):
self.__window = window
self.__main_controller = main_controller
self.__menu = None
def show(self):
if self.__menu is None:
self.__menu = Menu(self.__window)
self.__menu.add_command(label="save", command=self.__save)
self.__menu.add_command(label="back to main menu", command=self.__back)
self.__window.config(menu=self.__menu)
def remove(self):
if self.__menu is not None:
self.__menu.destroy()
self.__menu = None
def disable(self):
for i in range(3):
self.__menu.entryconfig(i, state="disabled")
def enable(self):
for i in range(3):
self.__menu.entryconfig(i, state="normal")
def __save(self):
self.__main_controller.show_save_menu()
def __back(self):
self.__main_controller.show_main_menu()
class field:
def __init__(self, master, typeOfUnit):
self.setType(typeOfUnit)
self.start = 0
self.master = master
self.menubar = Menu(master)
self.unitmenu = Menu(self.menubar, tearoff=0)
self.en = Entry(master, width=30)
self.en.grid(columnspan=10, sticky="N")
t = 0
r = 1
for i in range(Convert.numberOfUnits(self.ty)):
self.unitmenu.add_command(label=Convert.unitName(self.ty, i),
command=partial(self.toChange, i))
self.button = Button(master,
height=2,
width=5,
text=Convert.unitName(self.ty, i),
command=partial(self.changeType, i))
self.button.grid(row=r, column=i - (r - 1) * 4)
if t > 2:
t = 0
r += 1
else:
t += 1
self.menubar.add_cascade(label="start unit", menu=self.unitmenu)
master.config(menu=self.menubar)
self.label = Label(self.master)
def setType(self, typeOfUnit):
if typeOfUnit == "distance":
from Convert import distance as ty
elif typeOfUnit == "area":
from Convert import area as ty
elif typeOfUnit == "mass":
from Convert import mass as ty
elif typeOfUnit == "volume":
from Convert import volume as ty
elif typeOfUnit == "temperature":
from Convert import temperature as ty
elif typeOfUnit == "energy":
from Convert import energy as ty
self.ty = ty
def toChange(self, value):
self.start = value
self.menubar.entryconfig(1, label=Convert.unitName(self.ty, value))
def changeType(self, newType):
number = self.en.get()
self.label.destroy()
try:
number = float(number)
except:
self.label = Label(self.master, text="type in a number please")
self.label.grid(columnspan=12, sticky="SE")
return False
value = Convert.newUnit(self.ty, number,
Convert.unitName(self.ty, self.start),
Convert.unitName(self.ty, newType))
self.en.delete(0, 20)
self.label = Label(self.master,
height=3,
text=str(value) + " " +
Convert.unitName(self.ty, newType))
self.label.grid(columnspan=12, sticky="SE")
class MainMenu(Menu):
def __init__(self, root=None):
self.__root = root
Menu.__init__(self, self.__root)
# File
self.__menu_file = Menu(self, tearoff=False)
# regist env
self.__menu_file.add_command(label=ADD_ENV_SETUP_SCRIPT_LABEL,
command=self.__regist_env_setup_script)
# regist script
self.__menu_file.add_command(label=ADD_DATA_SCRIPT_LABEL,
command=self.__regist_data_script)
self.__menu_file.add_command(label=ADD_MODEL_SCRIPT_LABEL,
command=self.__regist_model_script)
self.__menu_file.add_command(label=ADD_TEST_FUNC_LABEL,
command=self.__regist_test_func_script)
self.__menu_file.add_separator()
# delete script
self.__menu_file.add_command(label=DELETE_SCRIPTS,
command=self.__delete_scripts)
self.__menu_file.add_separator()
# show env script list
self.__menu_file.add_command(label=SHOW_ENV_SETUP_M_LABEL,
command=self.__show_env_wizard)
self.add_cascade(label=FILE, menu=self.__menu_file)
# Run
self.__menu_rnu = Menu(self, tearoff=False)
# Run Verification
self.__menu_rnu.add_command(label=RUN_TEST_FUNC, command=self.__run)
# Stop Verification
self.__menu_rnu.add_command(label=STOP_TEST_FUNC,
command=self.__stop_test_func)
self.__menu_rnu.entryconfig(1, state=DISABLED)
self.add_cascade(label=RUN, menu=self.__menu_rnu)
# self.add_command(label=HELP, command=show_help)
self.__main_window = self.__root.children['!mainwindow']
self.__test_select_frame = self.__main_window.test_select_frame
def __show_env_wizard(self):
try:
self.__main_window.is_running = True
self.__menu_file.entryconfig(0, state=DISABLED)
self.__menu_file.entryconfig(7, state=DISABLED)
env_setup_wizard = EnvSetupWizard(master=self.master,
select_mode=BROWSE,
view_mode=True,
size=12)
show_wizard(wizard=env_setup_wizard,
title=SHOW_ENV_SETUP_WIZARD_TITLE,
modal=False)
finally:
self.__menu_file.entryconfig(0, state=NORMAL)
self.__menu_file.entryconfig(7, state=NORMAL)
self.__main_window.is_running = False
def __regist_env_setup_script(self):
try:
self.__main_window.is_running = True
# Show File Select Dialog
file_path = filedialog.askopenfilename(
filetypes=[('All Files', '*.*')], title=ENV_SETUP_WIZARD_TITLE)
if file_path:
# Check if it is already registed
env_setup = EnvSetupInfo.get_data_with_path(file_path)
if env_setup is None:
# Add Env Setup
env_setup = EnvSetup(path=file_path)
EnvSetupInfo.add_data(env_setup)
try:
save_config()
self.__main_window.c_println(ADD_NEW_SCRIPT_MSG %
env_setup.abs_path,
mode=INFO)
except Exception as e:
self.__main_window.c_println(os.linesep + str(e),
ERROR)
else:
self.__main_window.c_println(ALREADY_SCRIPT_MSG %
(ENV_SETUP, env_setup.id),
mode=INFO)
finally:
self.__main_window.is_running = False
def __regist_data_script(self):
try:
self.__main_window.is_running = True
# Show File Select Dialog
file_path = filedialog.askopenfilename(
filetypes=[('Python File', '*.py')],
title=DATA_SCRIPT_WIZARD_TITLE)
if file_path:
# show env select wizard
env_setup_wizard = EnvSetupWizard(master=self.master, size=12)
show_wizard(wizard=env_setup_wizard,
title=ENV_SET_WIZARD_TITLE)
env_id = env_setup_wizard.env_setup_id
if len(env_id) == 0:
return
# Check if it is already registed
data_script = DataScriptInfo.get_data_with_path(path=file_path)
if data_script is None:
# Add Data
data_script = DataScript(path=file_path, env_id=env_id)
DataScriptInfo.add_data(data_script)
# Update CONF
try:
save_config()
self.__main_window.c_println(ADD_NEW_SCRIPT_MSG %
data_script.abs_path,
mode=INFO)
except Exception as e:
self.__main_window.c_println(os.linesep + str(e),
ERROR)
return
else:
self.__main_window.c_println(ALREADY_SCRIPT_MSG %
(DATA_SCRIPT, data_script.id),
mode=INFO)
# Update MainWindow
self.__test_select_frame.update_list_items()
finally:
self.__main_window.is_running = False
def __regist_model_script(self):
try:
self.__main_window.is_running = True
# Show File Select Dialog
file_path = filedialog.askopenfilename(
filetypes=[('Python File', '*.py')],
title=MODEL_SCRIPT_WIZARD_TITLE)
if file_path:
# show env select wizard
env_setup_wizard = EnvSetupWizard(master=self.master, size=12)
show_wizard(wizard=env_setup_wizard,
title=ENV_SET_WIZARD_TITLE)
env_id = env_setup_wizard.env_setup_id
if len(env_id) == 0:
return
# Check if it is already registed
model = ModelScriptInfo.get_data_with_path(path=file_path)
if model is None:
# Add Model Load
model = ModelScript(path=file_path, env_id=env_id)
ModelScriptInfo.add_data(model)
# Update CONF
try:
save_config()
self.__main_window.c_println(ADD_NEW_SCRIPT_MSG %
model.abs_path,
mode=INFO)
except Exception as e:
self.__main_window.c_println(os.linesep + str(e),
ERROR)
return
else:
self.__main_window.c_println(ALREADY_SCRIPT_MSG %
(MODEL_SCRIPT, model.id),
mode=INFO)
# Update MainWindow
self.__test_select_frame.update_list_items()
finally:
self.__main_window.is_running = False
def __regist_test_func_script(self):
try:
self.__main_window.is_running = True
# Show File Select Dialog
file_path = filedialog.askopenfilename(
filetypes=[('Python File', '*.py')],
title=TEST_FUNC_WIZARD_TITLE)
if file_path:
# show env select wizard
env_setup_wizard = EnvSetupWizard(master=self.master, size=12)
show_wizard(wizard=env_setup_wizard,
title=ENV_SET_WIZARD_TITLE)
env_id = env_setup_wizard.env_setup_id
if len(env_id) == 0:
return
# Check if it is already registed
test_func = TestFuncInfo.get_data_with_path(path=file_path)
if test_func is None:
# Add Test Function
test_func = TestFunc(path=file_path, env_id=env_id)
TestFuncInfo.add_data(test_func)
# Update CONF
try:
save_config()
self.__main_window.c_println(ADD_NEW_SCRIPT_MSG %
test_func.abs_path,
mode=INFO)
except Exception as e:
self.__main_window.c_println(os.linesep + str(e),
ERROR)
return
else:
self.__main_window.c_println(ALREADY_SCRIPT_MSG %
(TEST_FUNC, test_func.id),
mode=INFO)
# Update MainWindow
self.__test_select_frame.update_list_items()
finally:
self.__main_window.is_running = False
def __delete_scripts(self):
# Delete Scripts
del_dict = self.__test_select_frame.delete_selected()
# Save Config
save_config()
# Show Deleted Message
if len(del_dict[TEST_FUNC]) > 0:
self.__del_print(del_dict[TEST_FUNC])
if len(del_dict[DATA_SCRIPT]) > 0:
self.__del_print(del_dict[DATA_SCRIPT])
if len(del_dict[MODEL_SCRIPT]) > 0:
self.__del_print(del_dict[MODEL_SCRIPT])
def __del_print(self, del_list):
for v in del_list:
self.__main_window.c_println(DELET_MSG % v, mode=INFO)
def __run(self):
try:
self.__main_window.is_running = True
self.__menu_rnu.entryconfig(0, state=DISABLED)
self.__menu_rnu.entryconfig(1, state=NORMAL)
self.__main_window.test_func_run()
finally:
self.__menu_rnu.entryconfig(0, state=NORMAL)
self.__menu_rnu.entryconfig(1, state=DISABLED)
self.__main_window.is_running = False
def __stop_test_func(self):
self.__main_window.is_running = False
self.__main_window.stop_test_func()
class GUI(Frame): # pylint: disable=too-many-ancestors
"""class for GUI"""
static_logger = logging.getLogger(__name__)
static_queue = queue.Queue()
def __init__(self, parent, db, pab, alg):
"""init"""
Frame.__init__(self, parent)
self.right_list = Listbox(parent)
self.left_list = Listbox(parent)
self.parent = parent
self.db_creator = db
self.path_and_bag = pab
self.alg_do = alg
self.menu_bar = Menu(self.parent)
self.init_ui()
def init_ui(self):
"""getting all things started"""
self.parent.title("PyMeno")
self.left_list.bind("<Double-Button-1>", self.on_double_click)
self.parent.config(menu=self.menu_bar)
file_menu = Menu(self.menu_bar, tearoff=False)
menu2_parse = Menu(self.menu_bar, tearoff=False)
# menu3_parse = Menu(menu_bar, tearoff=False)
# sub_menu = Menu(file_menu, tearoff=False)
self.left_list.pack(side=LEFT, fill=BOTH, expand=2)
self.right_list.pack(side=RIGHT, fill=BOTH, expand=2)
# add something to menu
file_menu.add_command(label="Choose folder with music ALG 1",
underline=0, command=self.new_thread_2)
file_menu.add_command(label="Choose folder with music ALG 2",
underline=0, command=self.new_thread_1)
file_menu.add_command(label="Choose folder with music ALG 3",
underline=0, command=self.new_thread_2)
file_menu.add_command(label="Exit", underline=0, command=self.on_exit)
menu2_parse.add_command(label="Download artists list", underline=0,
command=self.db_creator.download_list_of_artists)
menu2_parse.\
add_command(label="Parse artists information to database", underline=0,
command=self.go_to_lilis_parsing)
self.menu_bar.add_cascade(label="File", underline=0, menu=file_menu)
self.menu_bar.add_cascade(label="Data", underline=0, menu=menu2_parse)
def on_exit(self):
"""quit"""
GUI.static_queue.put("endino-tarantino")
self.quit()
def disable_menu(self):
"""disable menu while program is working"""
self.menu_bar.entryconfig("File", state="disabled")
self.menu_bar.entryconfig("Data", state="disabled")
def enable_menu(self):
"""enable menu after work"""
self.menu_bar.entryconfig("File", state="normal")
self.menu_bar.entryconfig("Data", state="normal")
def new_thread_1(self):
"""thread for the first algorythm"""
dir_name = filedialog.askdirectory(parent=self, initialdir="/",
title='Please select a directory')
if dir_name != "":
self.disable_menu()
self.path_and_bag.check_if_refresh(dir_name)
self.config(cursor="wait")
self.update()
self.clean_queue()
GUI.static_queue.put("Finding files in chosen folder:\n\n")
num_files = len([val for sub_list in
[[os.path.join(i[0], j)for j in i[2]]
for i in os.walk(dir_name)]
for val in sub_list])
rott = tk.Tk()
app = App(rott, GUI.static_queue, num_files)
rott.protocol("WM_DELETE_WINDOW", app.on_closing)
thread = threading.Thread(target=self.open_menu, args=(dir_name,))
thread.setDaemon(True)
thread.start()
app.mainloop()
else:
print("Action aborted")
def open_menu(self, dir_name):
"""select directory with music, alg 1"""
list_of_songs = []
self.path_and_bag.clear_bag_of_words()
for data in os.walk(dir_name):
for filename in data[2]:
list_of_songs = self.path_and_bag.change_title(os.path.join(data[0], filename))
GUI.static_queue.put(filename)
if not list_of_songs:
print("action aborted")
else:
GUI.static_queue.put("\nAnd what we have here?:\n")
self.config(cursor="")
shared_items_add = self.alg_do.search_for_simmilar_ver_2(False, GUI.static_queue)
if not shared_items_add:
shared_items_add = self.alg_do.search_for_simmilar_ver_2(True, GUI.static_queue)
if shared_items_add:
self.left_list.delete(0, END)
self.right_list.delete(0, END)
for song in list_of_songs:
temp = song.split(',', 1)
self.insert_to_right_list_box(temp[0], temp[1])
for key, value in shared_items_add.items():
temp = key.split(',', 1)
GUI.static_queue.put(temp[0] + " : " + value)
self.insert_to_left_list_box(temp[0] + " : " + value)
GUI.static_queue.put("endino-tarantino")
self.enable_menu()
def new_thread_2(self):
"""thread for the second algorythm"""
dir_name = filedialog.askdirectory(parent=self, initialdir="/",
title='Please select a directory')
if dir_name != "":
self.disable_menu()
self.path_and_bag.check_if_refresh(dir_name)
self.config(cursor="wait")
self.update()
self.clean_queue()
GUI.static_queue.put("Finding files in chosen folder:\n\n")
num_files = len([val for sub_list in
[[os.path.join(i[0], j)for j in i[2]]
for i in os.walk(dir_name)]
for val in sub_list])
rott = tk.Tk()
app = App(rott, GUI.static_queue, num_files)
rott.protocol("WM_DELETE_WINDOW", app.on_closing)
thread = threading.Thread(target=self.open_menu_ver_2, args=(dir_name,))
thread.setDaemon(True)
thread.start()
app.mainloop()
else:
print("Action aborted")
@staticmethod
def clean_queue():
"""cleaning queue if user exit manualy"""
if not GUI.static_queue.empty():
while not GUI.static_queue.empty():
GUI.static_queue.get()
def open_menu_ver_2(self, dir_name):
"""select directory with music, alg 2"""
list_of_songs = []
self.path_and_bag.clear_bag_of_words()
for data in os.walk(dir_name):
for filename in data[2]:
list_of_songs = self.path_and_bag.change_title(os.path.join(data[0], filename))
GUI.static_queue.put(filename)
if not list_of_songs:
print("action aborted")
else:
GUI.static_queue.put("\nAnd what we have here?:\n")
self.config(cursor="")
shared_items_add = self.alg_do.search_for_simmilar_ver_1(False, GUI.static_queue)
if not shared_items_add:
shared_items_add = self.alg_do.search_for_simmilar_ver_1(True, GUI.static_queue)
if shared_items_add:
self.left_list.delete(0, END)
self.right_list.delete(0, END)
for song in list_of_songs:
temp = song.split(',', 1)
self.insert_to_right_list_box(temp[0], temp[1])
for key, value in shared_items_add.items():
temp = key.split(',', 1)
self.insert_to_left_list_box(temp[0] + " : " + value)
GUI.static_queue.put("endino-tarantino")
self.enable_menu()
def new_thread_3(self):
"""thread for the third algorythm"""
dir_name = filedialog.askdirectory(parent=self, initialdir="/",
title='Please select a directory')
if dir_name != "":
self.disable_menu()
self.path_and_bag.check_if_refresh(dir_name)
self.config(cursor="wait")
self.update()
self.clean_queue()
GUI.static_queue.put("Finding files in chosen folder:\n\n")
num_files = len([val for sub_list in
[[os.path.join(i[0], j)
for j in i[2]] for i in os.walk(dir_name)]
for val in sub_list])
rott = tk.Tk()
app = App(rott, GUI.static_queue, num_files)
rott.protocol("WM_DELETE_WINDOW", app.on_closing)
thread = threading.Thread(target=self.open_menu_ver_3, args=(dir_name,))
thread.setDaemon(True)
thread.start()
app.mainloop()
else:
print("Action aborted")
def open_menu_ver_3(self, dir_name):
"""select directory with music, alg 3"""
list_of_songs = []
self.path_and_bag.clear_bag_of_words()
for data in os.walk(dir_name):
for filename in data[2]:
list_of_songs = self.path_and_bag.change_title(os.path.join(data[0], filename))
GUI.static_queue.put(filename)
print(list_of_songs)
if not list_of_songs:
print("action aborted")
else:
GUI.static_queue.put("\nAnd what we have here?:\n")
self.config(cursor="")
shared_items_add = self.alg_do.search_for_simmilar_ver_3(False, GUI.static_queue)
if not shared_items_add:
shared_items_add = self.alg_do.search_for_simmilar_ver_3(True, GUI.static_queue)
if shared_items_add:
self.left_list.delete(0, END)
self.right_list.delete(0, END)
for song in list_of_songs:
temp = song.split(',', 1)
self.insert_to_right_list_box(temp[0], temp[1])
for key, value in shared_items_add.items():
temp = key.split(',', 1)
self.insert_to_left_list_box(temp[0] + " : " + value)
GUI.static_queue.put("endino-tarantino")
self.enable_menu()
def insert_to_right_list_box(self, artist, song):
"""insert to right listbox for other methods"""
self.right_list.insert(END, artist + " - " + song)
def insert_to_left_list_box(self, artist):
"""insert to left listbox for other methods"""
self.left_list.insert(END, artist)
def go_to_lilis_parsing(self):
"""how many artist do you want to parse"""
number_from = simpledialog.askstring('Number', 'How many artists?/FROM')
if number_from is not None:
number_from = int(number_from)
print(number_from)
number_to = int(simpledialog.askstring('Number', 'How many artists?/TO'))
if number_to is not None:
number_to = int(number_to)
print(number_to)
self.db_creator.parse_file(number_to, number_from)
def on_double_click(self, event):
"""open youtube on double click"""
new = 2 # open in a new tab, if possible
widget = event.widget
selection = widget.curselection()
value = widget.get(selection[0])
url = self.youtube_search(value)
webbrowser.open(url, new=new)
@staticmethod
def youtube_search(to_search):
"""
This function finds url to our songs throw Youtube API
"""
developer_key = "AIzaSyCn9Pk4vWC8LjjIKqol5gkku20DI0IRurU"
youtube_api_service_name = "youtube"
youtube_api_version = "v3"
parse = argparse.ArgumentParser()
parse.add_argument("--q", help="Search term", default=to_search)
parse.add_argument("--max-results", help="Max results", default=25)
args = parse.parse_args()
youtube = build(youtube_api_service_name,
youtube_api_version, developerKey=developer_key)
# Call the search.list method to retrieve results matching the specified
# query term.
search_response = youtube.search().list(q=args.q, # pylint: disable=no-member
part="id,snippet",
maxResults=args.max_results,
order="viewCount").execute()
videos = []
channels = []
play_lists = []
# Add each result to the appropriate list, and then display the lists of
# matching videos, channels, and play lists.
for search_result in search_response.get("items", []):
if search_result["id"]["kind"] == "youtube#video":
videos.append(search_result["id"]["videoId"])
elif search_result["id"]["kind"] == "youtube#channel":
channels.append("%s (%s)" % (search_result["snippet"]["title"],
search_result["id"]["channelId"]))
elif search_result["id"]["kind"] == "youtube#playlist":
play_lists.append("%s (%s)" % (search_result["snippet"]["title"],
search_result["id"]["playlistId"]))
try:
return "https://www.youtube.com/watch?v=" + videos[0]
except (UnicodeEncodeError, IndexError):
GUI.static_logger.error('ERROR', exc_info=True)
return "https://www.youtube.com/watch?v=" + "_NXrTujMP50"
class ImageZip(Frame):
def __init__(self, parent):
# Bind Frame to self and begin UI
Frame.__init__(self, parent)
self.parent = parent
self.onGetZipResults = {}
self.imagetypes = [("Image file", "*.jpg"), ("Image file", "*.jpeg"),
("Image file", "*.jfif"), ("Image file", "*.jpe"),
("Image file", "*.jfi"), ("Image file", "*.jif")]
self.initUI()
def initUI(self):
# Creating UI elements and action calls
self.parent.title("JPEG 2 Zip Code")
self.pack(fill=BOTH, expand=True)
# Menu
menubar = Menu(self.parent)
fileMenu = Menu(menubar, tearoff=False)
fileMenu.add_command(label="Open File(s)", command=self.onOpenFile)
fileMenu.add_command(label="Exit", command=self.parent.quit)
menubar.add_cascade(label="File", menu=fileMenu)
self.editMenu = Menu(menubar, tearoff=False)
self.editMenu.add_command(label="Select All", command=self.onSelectAll)
self.editMenu.add_command(label="Deselect All",
command=self.onDeselectAll)
menubar.add_cascade(label="Edit", menu=self.editMenu)
self.actionMenu = Menu(menubar, tearoff=False)
self.actionMenu.add_command(label="Get ZIP Codes",
command=self.onGetZIP)
menubar.add_cascade(label="Action", menu=self.actionMenu)
self.parent.config(menu=menubar)
self.menuItemAccess(
False) # Disable unneeded menu items until files loaded
# Listbox which will hold opened file names and allow selection
self.listboxFiles = Listbox(self.parent, selectmode=EXTENDED)
self.listboxFiles.pack(fill=BOTH, expand=True)
def onDeselectAll(self):
self.listboxFiles.select_clear(0, END)
def onSelectAll(self):
self.listboxFiles.select_set(0, END)
# Takes in boolean, TRUE = allow access, FALSE = disable access
def menuItemAccess(self, viewable):
if viewable == True:
self.editMenu.entryconfig(0, state=NORMAL)
self.editMenu.entryconfig(1, state=NORMAL)
self.actionMenu.entryconfig(0, state=NORMAL)
if viewable == False:
self.editMenu.entryconfig(0, state=DISABLED)
self.editMenu.entryconfig(1, state=DISABLED)
self.actionMenu.entryconfig(0, state=DISABLED)
def badImageDialog(self, badimagefiles):
# Takes in a list of files and produces a warning dialog
fileerrors = ""
for file in badimagefiles:
fileerrors += str(file) + '\n'
messagebox.showwarning(
"Error Loading All Images",
"Not all images were found to be valid. The following files will not be loaded...\n"
+ fileerrors)
def onGetZIP(self):
# Produces GPS, then ZIP codes for all selected files in the UI.
geolocator = Nominatim(user_agent="JPEG2ZIP")
selectedfiles = self.listboxFiles.curselection()
for item in selectedfiles:
currentFile = self.listboxFiles.get(item)
currentGPS = getEXIF().load(currentFile)
print(currentGPS)
try:
temp = geolocator.reverse(currentGPS)
currentZIP = temp.raw['address']['postcode']
except: # If ZIP code not found or coords are (0.0, 0.0)
currentZIP = "Error"
# Unused right now but still saved.
# Adds {index: FileName, GPS Coords, ZIP code} to dictionary
self.onGetZipResults.update(
{item: (currentFile, getEXIF().load(currentFile), currentZIP)})
#Update UI
self.listboxFiles.delete(item)
self.listboxFiles.insert(item, currentFile + ' ' + currentZIP)
#print(self.onGetZipResults)
def onOpenFile(self):
# TODO: Grab and display thumbnails with file name.
fl = filedialog.askopenfilenames(filetypes=self.imagetypes)
# Image validity check and update UI with file names
print('Opening...')
badimagefiles = []
if fl != '':
for file in fl:
if (self.isValidJPEG(file) == True): # is valid
print('\t' + file)
self.listboxFiles.insert(END, file)
if (self.isValidJPEG(file) == False): # is invalid
badimagefiles.append(file)
if len(badimagefiles) > 0: # push bad images to dialog box
self.badImageDialog(badimagefiles)
# Enable Menu items
self.menuItemAccess(True)
def isValidJPEG(self, imageFile):
# TODO: use library to check validity of image. No need to reinvent the wheel.
try:
data = open(imageFile, 'rb').read(11) #read first 11 bytes
# All JPEG image files start off with SOI '0xff 0xd8'.
# This is slightly unnecessary. See TODO above.
if data[:2] != b'\xff\xd8': #Bad SOI
return False
return True
except:
print("Image Validation Error: Unable to open image " +
imageFile) # sanity check (print to console)
return False
class GuiKtl(Tk):
"""Handle the graphical interface for ktl2help and most of the logic"""
def __init__(self, parent):
"""initialize the GuiCore"""
Tk.__init__(self, parent)
self.parent = parent
self._initialize_variables()
# with open('LOCALIZED_TEXT.json', 'r') as f:
# self.LT = json.load(f)
lines = Path('LOCALIZED_TEXT.json').read_text(encoding='utf-8')
self.LT = json.loads(lines)
langs = sorted(list(self.LT.keys()))
self.INTERFACE_LANGS = langs
lang = 'en-US'
self._initialize_main_window_menu(lang)
self._initialize_main_window_notebook(lang)
self._initialize_main_window(lang)
if platform.system() not in ['Windows', 'Linux']:
# so on f0, the Project tab…
messagebox.showwarning(
'Warning', "Help I've been kidnaped by {platform.system()}!!!")
self._initialize_f7(lang) # make keyman files and help docs
ktl2help_styles = Style()
ktl2help_styles.configure('lowlight.TButton',
font=('Sans', 8, 'bold'),)
ktl2help_styles.configure('highlght.TButton',
font=('Sans', 11, 'bold'),
background='white', foreground='#007F00')
ktl2help_styles.configure('wleft.TRadiobutton',
anchor='w', justify='left')
def _initialize_variables(self):
"""initialize variables for GuiCore"""
self.font = font.Font()
self.script_dir = SCRIPT_DIR
self.klcfiles = list()
self.int_var = IntVar()
self.current_project = StringVar()
self.currentSrcDir = StringVar()
self.selected_lang = StringVar()
self.currentEntry = StringVar()
self.set_field = StringVar()
self.spklDir = StringVar()
self.kmflDir = StringVar()
self.f7ktl = StringVar()
self.menubar = Menu(self)
self.filemenu = Menu(self.menubar)
self.helpmenu = Menu(self.menubar)
def _initialize_main_window_menu(self, lang='en-US'):
"""initialize the menubar on the main window"""
self.option_add('*tearOff', FALSE)
self.config(menu=self.menubar)
self.menubar.add_cascade(label=self.LT[lang]['File'],
menu=self.filemenu)
self.filemenu.add_separator()
self.filemenu.add_command(label=self.LT[lang]['Exit'],
command=self.quit)
self.menubar.add_cascade(label=self.LT[lang]['Help'],
menu=self.helpmenu)
self.helpmenu.add_command(label=self.LT[lang]['Read Me'],
command=self._on_read_me)
self.helpmenu.add_command(label=self.LT[lang]['About...'],
command=on_copyright)
def _initialize_main_window_notebook(self, lang):
"""initializes notebook widget on main window"""
# self.n = Notebook(self, width=1400)
# notebook
self.n = Notebook(self, width=1015)
self.n.grid(column=0, columnspan=7, row=1, padx=5, pady=5, sticky='ew')
self.grid_rowconfigure(1, weight=1)
self.grid_columnconfigure(0, weight=1)
self.n.grid_rowconfigure(0, weight=1)
self.n.grid_columnconfigure(0, weight=1)
self.f7 = Frame(self.n)
self.n.add(self.f7, text=self.LT[lang]['Make help files'])
def _initialize_main_window(self, lang='en-US'):
""" initialize the main window"""
self.f_1 = Frame(self)
self.f_1.grid(column=0, row=0, sticky='news')
self.f_1.grid_rowconfigure(0, weight=0)
self.f_1.grid_columnconfigure(0, weight=0)
# in top of window
self.lblGuiLanguage = Label(self.f_1,
text=self.LT[lang]['0InterfaceLanguage>'])
self.lblGuiLanguage.grid(column=4, row=0, padx=5, pady=5, sticky='e')
self.lblGuiLanguage['justify'] = 'right'
# Create and fill the dropdown ComboBox.
self.ddnGuiLanguage = Combobox(self.f_1,
textvariable=self.selected_lang)
self.ddnGuiLanguage.grid(column=5, columnspan=1, row=0,
padx=5, pady=5, sticky='w')
self.ddnGuiLanguage['text'] = 'Interface language:'
self.ddnGuiLanguage['justify'] = 'left'
self.ddnGuiLanguage.bind('<<ComboboxSelected>>', self._change_lang)
# self.ddnGuiLanguage['values'] = [self.INTERFACE_LANGS['langs'][k] \
# for k in sorted(self.INTERFACE_LANGS['langs'])]
self.ddnGuiLanguage['values'] = self.INTERFACE_LANGS
self.ddnGuiLanguage.set(self.INTERFACE_LANGS[0])
# self.lblMode = Label(self.f_1, text=self.LT[lang]['Mode>'])
# self.lblMode.grid(column=6, row=0, padx=5, pady=5, sticky='e')
# assumes tab based interface
# main frame holds gui interface lange pull down, lists current project,
# and save settings button
self.progbar = Progressbar(self, maximum=100, variable=self.int_var)
self.progbar.grid(column=0, row=6, columnspan=8, padx=5, pady=5,
sticky='news')
self.status = Label(self, text=self.LT[lang]['empty string'],
anchor='w', justify='left')
self.status.grid(column=0, row=7, columnspan=8, padx=5, pady=5,
sticky='news')
def _initialize_f7(self, lang):
"""initialize Make/Remake help files tab from project ktl/kmn/kvks.
Has text box and browse button to ktl file,
plus OK - Make/Remake help files, creating any necessary folders.
All help files created relative to position of ktl file.
A common file name and location assumed for
ktl, kmn and kvks files, only the extensions differ."""
self.lblf7Intro = Label(self.f7,
text=self.LT[lang]["f7Intro"],
anchor='w', justify='left') # , wraplength=600)
self.lblf7Intro.grid(column=0, row=0,
columnspan=4, padx=5, pady=5, sticky='news')
# Source Directory -label, entrybox, browse button
self.lblf7ktl = Label(self.f7,
text=self.LT[lang]['f7ktl'],
anchor='w', justify='left')
self.lblf7ktl.grid(column=0, row=1, columnspan=1, padx=5, pady=5,
sticky='w')
self.lblf7ktlfile = Label(self.f7, textvariable=self.f7ktl,
anchor='w', justify='left')
self.lblf7ktlfile.grid(column=1, row=1, columnspan=2, padx=5, pady=5,
sticky='w')
self.btnf7Browse = Button(self.f7, text="...",
command=self._on_f7_browse,
style='highlight.TButton')
self.btnf7Browse.grid(column=3, row=1, padx=5, pady=5, sticky='news')
self.btnf7Browse_ttp = CreateToolTip(self.f7,
self.LT[lang]['f7Browse_ttp'])
self.btnf7MakeHelp = Button(self.f7,
text=self.LT[lang]["Make help files"],
command=self._on_f7_make_help,
style='highlight.TButton')
self.btnf7MakeHelp.grid(column=2, row=20, columnspan=2, padx=5, pady=5,
sticky='news')
def _on_f7_browse(self):
"""browse to ktl file and load path into self.f7ktl"""
lang = self.ddnGuiLanguage.get()
self.f7ktl.set(filedialog.askopenfilename(
initialdir=os.path.expanduser('~/Documents/Keyman Developer/Projects'),
title=self.LT[lang]["SelectKTLfile"],
filetypes=(('keyman file', '*.keyman-touch-layout'),
("all files", "*.*"))))
def _on_f7_make_help(self):
"""makes keyman help files"""
touch = Touch(Path(self.f7ktl.get()), Path(SCRIPT_DIR), self.LT)
touch.create_help_for_devices()
def _on_read_me(self):
"""calls the appropriate 'help' file from the menubar"""
lang = self.ddnGuiLanguage.get()
app_dir = get_script_directory()
# open an HTML file on my own computer
if lang == 'en-US':
url = os.path.normpath("file://" + app_dir + "/Read_Me.html")
elif lang == 'fr-FR':
url = os.path.normpath("file://" + app_dir + "/Lire_Moi.html")
elif lang == 'pt-PT':
# need portugese version, default to eng
url = os.path.normpath("file://" + app_dir + "/Read_Me.html")
else:
messagebox.showwarning('Warning',
f"Error in on_read_me: {lang} is unrecognised lang, defaulting to 'en-US.'")
url = os.path.normpath("file://" + app_dir + "/Read_Me.html")
webbrowser.open(url)
def _change_lang(self, lang):
'''change lang of labels to interfacelang'''
self.menubar.entryconfig(0, label=self.LT[lang]['File'])
self.menubar.entryconfig(1, label=self.LT[lang]['Help'])
self.filemenu.entryconfig(0,
label=self.LT[lang]['Load project settings'])
self.filemenu.entryconfig(1, label=self.LT[lang]['Save'])
self.filemenu.entryconfig(2,
label=self.LT[lang]['Delete project settings'])
self.filemenu.entryconfig(4, label=self.LT[lang]['Exit'])
self.helpmenu.entryconfig(0, label=self.LT[lang]['Read Me'])
self.helpmenu.entryconfig(1, label=self.LT[lang]['About...'])
self.lblGuiLanguage['text'] = \
self.LT[lang]['Interface language>']
self.lblProject['text'] = self.LT[lang]['Current Project>'] + \
' ' + self.ddnCurProject.get()
self.lblMode['text'] = ''.join([self.LT[lang]['Mode>'],
self.LT[lang]["Simple"
if self.mode.get() == 0
else "Advanced"]])
self.lblCurTemplate_ttp['text'] = self.LT[lang]['CurTemplate_ttp']
self.lblCurTemplate['text'] = self.LT[lang]['UseTemplate>']
self.btnCreateTemplate['text'] = self.LT[lang]["CreateTemplate"]
self.btnSavePref['text'] = self.LT[lang]["SavePref"]
self.boxOptional['text'] = self.LT[lang]["Optional"]
self.lblInitialDigit['text'] = self.LT[lang]['InitialDigit']
self.lblIdiot['text'] = self.LT[lang]['IdiotMode']
self.rdbIdiot['text'] = self.LT[lang]['Simple']
self.rdbAdvanced['text'] = self.LT[lang]['Advanced']
self.f0_ttp['text'] = self.LT[lang]['f0_ttp']
self.lblLatin1['text'] = self.LT[lang]["AddLatin1Example"]
self.btnF2Next['text'] = self.LT[lang]["Next"]
self.lblM0['text'] = self.LT[lang]['M0_ttp']
self.lblM2['text'] = \
self.LT[lang]['M2_ttp1' if self.mode.get() == 1
else 'M2_ttp']
self.lblArt['text'] = self.LT[lang]["Art_ttp"]
self.lblCurProject['text'] = self.LT[lang]['Current Project>']
self.btnBuildOutputTo['text'] = self.LT[lang]['Output to>']
self.lblTrimTitle['text'] = self.LT[lang]['TrimTitle_ttp']
self.box0['text'] = self.LT[lang]["and/or"]
self.box1['text'] = self.LT[lang]['Adjust order of files']
self.box2['text'] = self.LT[lang]['As needed']
self.box1M1['text'] = self.LT[lang]['Change indent']
self.box2M1['text'] = self.LT[lang]['Change order']
self.labelf1['text'] = self.LT[lang]['labelf1']
class MainApplication(tk.Frame):
def __init__(self, master = None):
self.master = master
tk.Frame.__init__(self, master)
self.is_connect = 0
self.counter1 = 0
self.data = RxData()
self.desc = DescID()
self.counter_sel_all = 0
self.is_sel_all = tk.BooleanVar()
self.is_sel_all.set(0)
self.solomess = [tk.BooleanVar() for i in range(10)]
for i in range(10):
self.solomess[i].set(0)
self.solomessOnce = tk.BooleanVar()
self.solomessOnce.set(0)
self.is_sending = False
self.is_reading = False
self.is_logging = False
self.init_window()
def tabify(self, s, mode=0,tabsize=4):
if mode == 0:
ln = int((len(s) / tabsize) + 1) * tabsize
else:
s = s.ljust(tabsize)
s += "| "
return s
return s.ljust(ln)
def test(self):
self.sendList.insert(tk.END, str(self.solomess.get()))
def select_all(self):
if self.is_sel_all.get() == 1:
for i in range(10):
self.checkbtnSendArr[i].select()
else:
for i in range(10):
self.checkbtnSendArr[i].deselect()
def init_window(self):
defaultMainWindowSizeX = 615
defaultMainWindowSizeY = 580
self.master.title("CAN Scanner v0.0.1")
self.master.maxsize(615, 580)
self.master.minsize(615, 580)
self.master.geometry(str(defaultMainWindowSizeX) + "x" + str(defaultMainWindowSizeY))
self.frame1 = tk.Frame(self.master, bd=1, relief=tk.RAISED)
self.tkMenu = Menu(self.frame1)
self.master.config(menu=self.tkMenu)
self.tkMenuConnection = Menu(self.tkMenu, tearoff=0)
self.tkMenuAction = Menu(self.tkMenu, tearoff=0)
self.tkMenu.add_cascade(label="Connection", menu=self.tkMenuConnection)
self.tkMenuConnection.add_command(label="Connect", command=lambda: self.buttonConnectionClick())
self.tkMenu.add_cascade(label="Action", menu=self.tkMenuAction)
self.tkMenuAction.add_command(label="Read", command=lambda: self.buttonReadClick())
self.tkMenuAction.add_command(label="Save log", command=lambda: self.saveLogScript())
self.tkMenuAction.add_command(label="Reset", command=lambda: self.buttonReset())
self.master.bind('<Up>', view_event_up)
self.master.bind('<Down>', view_event_down)
self.master.bind('<MouseWheel>', view_event_scroll)
tabControl = ttk.Notebook(self)
tabReading = ttk.Frame(tabControl)
tabDesc = ttk.Frame(tabControl)
tabSending = ttk.Frame(tabControl)
tabControl.add(tabReading, text="Reading")
tabControl.add(tabDesc, text="Description")
tabControl.add(tabSending, text="Sending")
tabControl.pack(expand=tk.YES, fill=tk.BOTH)
tabControl.rowconfigure(0, weight=1)
tabControl.columnconfigure(0, weight=1)
tabReading.columnconfigure(0, weight=1)
tabReading.rowconfigure(0, weight=1)
tabDesc.columnconfigure(0, weight=1)
tabDesc.rowconfigure(0, weight=1)
tabSending.columnconfigure(0, weight=1)
tabSending.rowconfigure(0, weight=1)
sendFrame = tk.Frame(tabSending)
sendFrameLB = tk.Frame(tabSending)
sendFrame.pack(expand=tk.YES, fill=tk.X)
sendFrameLB.pack(expand=tk.YES, fill=tk.BOTH)
self.sendList = tk.Listbox(sendFrameLB, font='Courier 10')
self.sendList.pack(expand=tk.YES, fill=tk.BOTH)
self.textIDArr = [tk.Entry(sendFrame, width=8, font='Courier 8') for i in range(10)]
self.textDataArr = [[tk.Entry(sendFrame, width=2, font='Courier 8') for j in range(8)] for i in range(10)]
self.textCycleArr = [tk.Entry(sendFrame, width=5, font='Courier 8') for i in range(10)]
self.checkbtnSendArr = [tk.Checkbutton(sendFrame, text="Send", onvalue=1, offvalue=0, variable=self.solomess[i], state="normal", width=10) for i in range(10)]
self.idLabelArr = [tk.Label(sendFrame, text="ID: ") for i in range(10)]
self.dataLabelArr = [tk.Label(sendFrame, text="Data: ") for i in range(10)]
self.cycleLabelArr = [tk.Label(sendFrame, text="Cycle (ms): ") for i in range(10)]
for i in range(10):
self.textIDArr[i].grid(row=i, column=5, sticky=tk.N + tk.W, columnspan=3, padx=5, pady=5)
strID = ""
strID += "10" + str(i) + "00" + str(i) + "03"
self.textIDArr[i].insert(tk.INSERT, strID)
self.textIDArr[i].bind('<KeyRelease>', self.keyEventID)
for j in range(8):
self.textDataArr[i][j].grid(row=i, column=(j+9), sticky=tk.N + tk.W, padx=5, pady=5)
self.textDataArr[i][j].insert(tk.INSERT, "00")
self.textDataArr[i][j].bind('<KeyRelease>', self.keyEvent)
self.textCycleArr[i].grid(row=i, column=18, columnspan=2, sticky=tk.N + tk.W, padx=5, pady=5)
self.textCycleArr[i].insert(tk.INSERT, "500")
self.textCycleArr[i].bind('<KeyRelease>', self.keyEventCycle)
self.checkbtnSendArr[i].grid(row=i, column=0, columnspan=4, sticky=tk.N + tk.W, padx=0, pady=2)
#self.checkbtnSendArr[i].bind('<ButtonRelease-1>', self.check_click)
self.idLabelArr[i].grid(row=i, column=4, sticky=tk.N + tk.W, padx=0, pady=4)
self.dataLabelArr[i].grid(row=i, column=8, sticky=tk.N + tk.W, padx=0, pady=4)
self.cycleLabelArr[i].grid(row=i, column=17, sticky=tk.N + tk.W, padx=0, pady=4)
self.checkbtnSelAll = tk.Checkbutton(sendFrame, text="Select all", onvalue=1, offvalue=0, variable=self.is_sel_all, command=self.select_all, state="normal", width=10)
self.checkbtnSelAll.grid(row=12, column=0, columnspan=4, sticky=tk.N + tk.W, padx=0, pady=2)
self.buttonCanSend = tk.Button(sendFrame, wraplength=50, state="normal", text=r"Send", width=10,
command=self.buttonCANSendClick, relief=tk.RAISED)
self.buttonCanSend.grid(row=11, column=0, columnspan=4, sticky=tk.N + tk.W, padx=5, pady=5)
self.checkbtnCanSendOnce = tk.Checkbutton(sendFrame, text="Send once", onvalue=1, offvalue=0,
variable=self.solomessOnce, state="normal", width=10)
self.checkbtnCanSendOnce.grid(row=11, column=4, columnspan=4, sticky=tk.N + tk.W, padx=0, pady=5)
self.resLabel = tk.Label(sendFrame, text="")
self.resLabel.grid(row=11, column=8, columnspan=5, sticky=tk.N + tk.W, padx=5, pady=5)
self.listDesc = tk.Listbox(tabDesc, font='Courier')
self.listDesc.pack(expand=tk.YES, fill=tk.BOTH)
#self.listDesc.bind("<Double-Button-1>", openDescriptionEvent)
self.flLstResults = tk.Listbox(tabReading, font='Courier')
scrollbar = tk.Scrollbar(tabDesc, command=self.listDesc.xview, orient=tk.HORIZONTAL)
self.listDesc.configure(xscrollcommand=scrollbar.set)
scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
self.flLstResults.pack(expand=tk.YES, fill=tk.BOTH)
#self.flLstResults.bind("<Double-Button-1>", openDescriptionEvent)
self.pack(fill=tk.BOTH, expand=tk.YES)
self.master.mainloop()
def saveLogScript(self):
if self.is_logging is False and self.is_reading is True:
self.is_logging = True
self.reading.get_log(self.is_logging)
self.tkMenuAction.entryconfig(1, label="Stop saving log")
else:
self.is_logging = False
self.reading.get_log(self.is_logging)
self.tkMenuAction.entryconfig(1, label="Save log")
def scrollM(self):
if self.view_p == 0:
self.yview_listbox = tk.END
else:
self.yview_listbox = '0'
def check_my_msg(self):
self.counter1 += 1
w = self.master.geometry()
if self.counter1 >= 80:
self.counter1 = 0
data = self.reading.get_pack()
self.listDesc.delete(0, tk.END)
self.flLstResults.delete(0, tk.END)
self.listDesc.insert(tk.END,
u" ID | Отправитель | Приемник | Count")
self.listDesc.insert(tk.END,
"----------+---------------------+--------------+------")
self.flLstResults.insert(tk.END, u" ID | Данные | | Count")
self.flLstResults.insert(tk.END, "----------+----------------------------------+-----+------")
for i in range(0, len(data)):
self.listDesc.insert(tk.END, str(data[i][0]) + data[i][4] + data[i][5] + " | " + str(data[i][3]))
self.flLstResults.insert(tk.END, str(data[i][0]) + data[i][1] + "| " + str(data[i][2]) + " | " + str(data[i][3]))
self.listDesc.yview(yview_listbox)
self.flLstResults.yview(yview_listbox)
if self.is_connect == 1:
self.master.after(1, self.check_my_msg)
else:
return
def shortHEX(self, str1, num):
ret = ""
buff = str(hex(str1))
if len(buff[2:]) <= num:
ret += "0"
ret += buff[2:]
else:
ret += buff[2:]
return ret
def buttonReadClick(self):
if self.is_connect == 1:
if self.is_reading is False:
self.starttime = datetime.datetime.now()
self.reading = threadRead(self.siecaLibHandle, self.sieca_lib, self.starttime)
self.reading.start()
self.is_reading = self.reading.is_alive()
if self.is_reading is True:
self.check_my_msg()
return
def buttonReset(self):
if self.is_connect == 1:
if self.is_reading is True:
self.reading.reset()
def buttonConnectionClick(self):
if self.is_connect == 0:
self.buttonConnectClick()
else:
self.buttonDisconnectClick()
def buttonConnectClick(self):
if self.is_connect == 0:
self.sieca_lib = sieca132_client()
l_netnumber = 105
l_txtimeout = -1
l_rxtimeout = -1
c_canAppName = "canAppName"
c_ReceiverEventName = "RE1"
c_ErrorEventName = "EE1"
d_retval = self.sieca_lib.canOpen(l_netnumber, 0, 0, l_txtimeout, l_rxtimeout, c_canAppName,
c_ReceiverEventName, c_ErrorEventName)
if d_retval["l_retval"] == 0:
self.is_connect = 1
self.siecaLibHandle = d_retval["handle"]
l_retval = self.sieca_lib.canSetBaudrate(self.siecaLibHandle,
int(CANTypeDefs.Baudrate.BAUD_250)) # 250 kbits/sec
if l_retval == 0:
l_retval = self.sieca_lib.canBlinkLED(self.siecaLibHandle, 0, 0b111, 0b101)
if l_retval == 0:
l_retval = self.sieca_lib.canIsNetOwner(d_retval["handle"])
if l_retval == 0:
l_retval = self.sieca_lib.canSetFilterMode(self.siecaLibHandle, CANTypeDefs.T_FILTER_MODE.filterMode_nofilter)
if l_retval == 0:
global view_p
view_p = 0
self.tkMenuConnection.entryconfig(0, label="Disconnect")
#self.tkMenu.entryconfig(0, label="Disconnect")
else:
#message
pass
else:
pass
def getData(self):
all_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
all_cycles = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
all_is_clear = 0
for i in range(10):
if self.solomess[i].get() is True:
cycle_m = int(self.textCycleArr[i].get())
canmsg = CANTypeDefs.CMSG()
canmsg.l_id = int(self.textIDArr[i].get(), 16)
canmsg.by_len = 8
bytedata = bytearray(
[int(self.textDataArr[i][0].get(), 16), int(self.textDataArr[i][1].get(), 16), int(self.textDataArr[i][2].get(), 16),
int(self.textDataArr[i][3].get(), 16), int(self.textDataArr[i][4].get(), 16), int(self.textDataArr[i][5].get(), 16),
int(self.textDataArr[i][6].get(), 16), int(self.textDataArr[i][7].get(), 16)])
canmsg.aby_data[:] = bytedata
canmsg.by_extended = 1
canmsg.by_remote = 0
all_cycles[i] = cycle_m
all_data[i] = canmsg
else:
all_cycles[i] = 0
all_data[i] = 0
all_is_clear += 1
return all_data, 10-all_is_clear, all_cycles
def buttonCANSendClick(self):
if self.is_sending is False and self.is_connect == 1:
self.sendList.delete(0, tk.END)
all_msgs, self.count_msg, all_cycles = self.getData()
if self.count_msg == 0:
self.sendList.insert(tk.END, "Nothing selected!")
else:
if self.solomessOnce.get() is True:
for i in range(10):
if self.solomess[i].get() is True:
result = self.sieca_lib.canSend(self.siecaLibHandle, all_msgs[i], 1)
if result == 0:
strMsg = ""
strMsg += "Message " + str(i+1) + " sent."
self.sendList.insert(tk.END, strMsg)
else:
counter = 0
self.sending = []
for i in range(10):
if self.solomess[i].get() is True:
self.sending.append(threadSend(self.siecaLibHandle, all_msgs[i], self.sieca_lib, all_cycles[i]))
self.sending[counter].start()
if self.sending[counter].is_alive():
counter += 1
strMsg = ""
strMsg += "Message is sending."
self.sendList.insert(tk.END, strMsg)
if counter == self.count_msg:
self.is_sending = True
self.buttonCanSend.configure(text=r"Stop", relief=tk.SUNKEN)
for i in range(10):
self.checkbtnSendArr[i].configure(state=tk.DISABLED)
self.checkbtnCanSendOnce.configure(state=tk.DISABLED)
else:
if self.is_sending is True:
counter = 0
for i in range(self.count_msg):
self.sending[i].stapth()
self.sending[i].join()
if self.sending[i].is_alive() is False:
counter += 1
if counter == self.count_msg:
for i in range(10):
self.checkbtnSendArr[i].configure(state=tk.NORMAL)
self.checkbtnCanSendOnce.configure(state=tk.NORMAL)
self.buttonCanSend.configure(text=r"Send", relief=tk.RAISED)
self.sendList.insert(tk.END, "Sending was stopped")
self.is_sending = False
else:
self.sendList.insert(tk.END, "Connection was not found")
return
def buttonDisconnectClick(self):
if self.is_connect == 1:
if self.is_reading is True:
self.reading.stapth()
self.reading.join()
self.is_reading = self.reading.is_alive()
if self.is_reading is True:
return
if self.is_sending is True:
counter = 0
for i in range(self.count_msg):
self.sending[i].stapth()
self.sending[i].join()
if self.sending[i].is_alive() is False:
counter += 1
if counter == self.count_msg:
self.is_sending = False
self.checkbtnCanSendOnce.configure(state=tk.NORMAL)
self.buttonCanSend.configure(text=r"Send", relief=tk.RAISED)
self.sendList.insert(tk.END, "Sending was stopped")
for i in range(10):
self.checkbtnSendArr[i].configure(state=tk.NORMAL)
else:
return
l_retval = self.sieca_lib.canClose(self.siecaLibHandle)
if l_retval == 0:
self.is_connect = 0
global view_p
view_p = 2
self.tkMenuConnection.entryconfig(0, label="Connect")
return
def keyEvent(self, event):
if len(event.widget.get()) > 2:
event.widget.delete(0, tk.END)
def keyEventID(self, event):
if len(event.widget.get()) > 8:
event.widget.delete(0, tk.END)
def keyEventCycle(self, event):
if len(event.widget.get()) > 5:
event.widget.delete(0, tk.END)
def check_click(self, event):
counter_sel_all1 = 0
for i in range(10):
if self.solomess[i].get() is True:
counter_sel_all1 += 1
if counter_sel_all1 == 10:
self.checkbtnSelAll.select()
else:
self.checkbtnSelAll.deselect()
class Window(Frame):
def __init__(self, root, size=(500, 500)):
super().__init__()
self.root = root
self.size = size
self.root.geometry(str(self.size[0]) + "x" + str(self.size[1]) + "+0+0")
self.dicomHandler = None
self.canvas = None
self.imageShown = False
self.imagesToShow = []
self.imagesSlideshow = False
self.imagesMeta = []
self.imageCount = 0
self.points = []
self.pointsForImages = []
self.initUI()
def initUI(self):
self.master.title("Dicometer")
self.menubar = Menu(self.master)
self.master.config(menu=self.menubar)
fileMenu = Menu(self.menubar)
self.menubar.add_cascade(label="File", menu=fileMenu)
fileMenu.add_command(label="Open single file", command=self.onFileOpen)
fileMenu.add_command(label="Open directory", command=self.onDirOpen)
fileMenu.add_command(label="Exit", command=self.onExit)
slideshowControlls = Menu(self.menubar)
self.menubar.add_cascade(label="Controlls", menu=slideshowControlls)
slideshowControlls.add_command(label="Next", command=self.onNextImage)
slideshowControlls.add_command(label="Preview", command=self.onPreview)
slideshowControlls.add_command(label="View Metrics", command=self.onMetrics)
slideshowControlls.add_command(label="Export", command=self.onExport)
helpControlls = Menu(self.menubar)
self.menubar.add_cascade(label="Help", menu=helpControlls)
helpControlls.add_command(label="Reference", command=self.onReference)
self.menubar.entryconfig("Controlls", state="disabled")
self.initCanvas(self.size)
self.canvas.create_text(
self.size[0] >> 1,
self.size[1] >> 1,
text="Open file or directory by following File option",
fill="black"
)
def initCanvas(self, size):
if self.canvas:
self.canvas.destroy()
self.canvas = Canvas(self.root, width=size[0], height=size[1])
self.canvas.pack(expand=1)
self.canvas.bind("<Button-1>", self.onMouseClicked)
self.canvas.bind("<Button-3>", self.onMouseRightClicked)
def showImage(self, imageToShow):
width, height = np.array(imageToShow).shape
self.root.geometry(str(width) + "x" + str(height))
self.initCanvas((width, height))
img = ImageTk.PhotoImage(image=Image.fromarray(imageToShow))
self.root.img = img
self.canvas.create_image((0, 0), image=img, state="normal", anchor="nw")
self.imageShown = True
def redraw(self):
self.showImage(self.imagesToShow[self.imageCount])
self.drawDynamic()
def getPointsForImages(self, images):
print("Requesting points for images")
self.imagesToShow = images
self.imagesSlideshow = True
self.showImage(images[0])
self.showSlideshowMenu()
def showSlideshowMenu(self):
self.menubar.entryconfig("Controlls", state="normal")
def drawDynamic(self):
for point in self.points:
self.canvas.create_oval(
point[0] - POINT_RADIUS_HALF,
point[1] - POINT_RADIUS_HALF,
point[0] + POINT_RADIUS_HALF,
point[1] + POINT_RADIUS_HALF,
fill="#ff0000",
outline="#ff0000"
)
def onExit(self):
self.quit()
def onFileOpen(self):
path = filedialog.askopenfilename()
if path is None:
return
self.dicomHandler = DicomHandler(self, path, False)
images, meta = self.dicomHandler.parseFile(self.dicomHandler.path)
self.imagesMeta = [meta]
self.getPointsForImages(images)
def onDirOpen(self):
path = filedialog.askdirectory()
if path is None:
return
self.dicomHandler = DicomHandler(self, path, True)
images, meta = self.dicomHandler.parseDirectory()
self.imagesMeta = meta
self.getPointsForImages(images)
def onMouseClicked(self, event):
if self.imageShown:
point = (event.x, event.y)
self.points.append(point)
self.redraw()
def onMouseRightClicked(self, event):
if self.imageShown and len(self.points) != 0:
point = (event.x, event.y)
self.points = [x for x in self.points if abs(x[0] - point[0]) > 3 or abs(x[1] - point[1]) > 3]
self.redraw()
def onNextImage(self):
self.pointsForImages.append(self.points)
self.imageCount += 1
self.points = []
if len(self.imagesToShow) > self.imageCount:
self.showImage(self.imagesToShow[self.imageCount])
else:
messagebox.showinfo("No more images were opened", "You have pointed all images, export or preview now")
def getAllPoints(self):
return self.pointsForImages + [self.points]
def getXYZPoints(self):
X = []
Y = []
Z = []
for imageIndex, pointsForImage in enumerate(self.getAllPoints()):
for point in pointsForImage:
meta = self.imagesMeta[imageIndex]
x, y, z = getVoxelPosition(point, meta["pixelSpacing"], meta["imagePosition"], meta["imageOrientation"])
X.append(x)
Y.append(y)
Z.append(z)
return X, Y, Z
def onPreview(self):
X, Y, Z = self.getXYZPoints()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X, Y, Z)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
def getMetrics(self):
X, Y, Z = self.getXYZPoints()
xMax, xMin = np.amax(X), np.amin(X)
yMax, yMin = np.amax(Y), np.amin(Y)
zMax, zMin = np.amax(Z), np.amin(Z)
return abs(xMax - xMin), abs(yMax - yMin), abs(zMax - zMin)
def onMetrics(self):
x, y, z = self.getMetrics()
messagebox.showinfo("Metrix", "X metrix is " + str(x) + "mm \n"
"Y metrix is " + str(y) + "mm \n"
"Z metrix is " + str(z) + "mm \n"
)
def onExport(self):
includeMetrics = messagebox.askyesno("Export", "Would tou like to include metrics?")
path = filedialog.asksaveasfilename(defaultextension=".json")
if path is None:
return
x, y, z = self.getXYZPoints()
data = {
"points": {}
}
data["points"]["x"] = x
data["points"]["y"] = y
data["points"]["z"] = z
if includeMetrics:
x, y, z = self.getMetrics()
data["metrics"] = {}
data["metrics"]["x"] = x
data["metrics"]["y"] = y
data["metrics"]["z"] = z
data["metrics"]["units"] = "mm"
with open(path, 'w') as outfile:
json.dump(data, outfile)
messagebox.showinfo("Exported", "Operation is successful you can obtain your file at '" + path + "'")
def onReference(self):
messagebox.showinfo("Reference", "Menu: \n"
"Controlls -> Next: next picture in sequence \n"
"Controlls -> Export: Exports points data in .json format \n"
"Image proccessing: \n"
"To create point: left mouse click on canvas\n"
"To remove point: right mouse click on canvas near the corresponding point\n"
)
if len(themes) > 0:
show_themes[themes[0]].set(True)
style.theme_use(themes[0])
root.title("singles")
# root.iconbitmap('path/to/icon/bitmap')
menubar = Menu(root)
filemenu = Menu(menubar, tearoff=False)
filemenu.add_command(label="Open", command=donothing)
filemenu.add_command(label="Save", command=donothing)
filemenu.add_command(label="Save as...", command=donothing)
filemenu.add_command(label="Close", command=donothing)
filemenu.entryconfig("Save", state=DISABLED)
filemenu.entryconfig("Save as...", state=DISABLED)
filemenu.entryconfig("Close", state=DISABLED)
filemenu.add_separator()
submenu = Menu(menubar, tearoff=False)
themes_menu = Menu(submenu, tearoff=False)
for theme in themes:
themes_menu.add_checkbutton(label=theme.capitalize(),
onvalue=1,
offvalue=0,
variable=show_themes[theme],
command=partial(ontheme, theme))
submenu.add_cascade(label='Themes', menu=themes_menu)
submenu.add_command(label="Settings")
class MenuPresenter(Frame):
# Menu labels
FILE_MENU_LABEL = "File"
HELP_MENU_LABEL = "Help"
# Menu options
NEW_GAME_MENU_OPTION = "New Game"
EXIT_MENU_OPTION = "Exit"
SHOW_RULES_MENU_OPTION = "Show Rules"
# Menu options mapped to their respective menus
MENU_OPTIONS_DICT = {
NEW_GAME_MENU_OPTION: FILE_MENU_LABEL,
EXIT_MENU_OPTION: FILE_MENU_LABEL,
SHOW_RULES_MENU_OPTION: HELP_MENU_LABEL
}
# Rules msg box title and rules doc
RULES_MSGBOX_TITLE = "Pirate Battleship Rules"
RULES_FILE_PATH = "incl/rules.txt"
def __init__(self, app, menu):
Frame.__init__(self, app)
self.fileMenu = Menu(menu, tearoff=0)
self.helpMenu = Menu(menu, tearoff=0)
self.fileMenuOptions = {}
self.helpMenuOptions = {}
self._create_menus()
menu.add_cascade(label=self.FILE_MENU_LABEL, menu=self.fileMenu)
menu.add_cascade(label=self.HELP_MENU_LABEL, menu=self.helpMenu)
self.master.config(menu=menu)
"""Create menus for top menu bar and attach options"""
def _create_menus(self):
i = 0
j = 0
for menuOption, menuLabel in self.MENU_OPTIONS_DICT.items():
if menuLabel is self.FILE_MENU_LABEL:
self.fileMenu.add_command(label=menuOption)
self.fileMenuOptions[self._create_menu_key(menuLabel, menuOption)] = i
i += 1
elif menuLabel is self.HELP_MENU_LABEL:
self.helpMenu.add_command(label=menuOption)
self.helpMenuOptions[self._create_menu_key(menuLabel, menuOption)] = j
j += 1
"""Attach a function to a menu option"""
def attach_menu_cmd(self, label, option, cmd):
if label is self.FILE_MENU_LABEL:
self.fileMenu.entryconfig(self.fileMenuOptions[self._create_menu_key(label, option)], command=cmd)
elif label is self.HELP_MENU_LABEL:
self.helpMenu.entryconfig(self.helpMenuOptions[self._create_menu_key(label, option)], command=cmd)
"""Display the games rules (for 'Rules' menu option)"""
def display_game_rules(self):
file = open(self.RULES_FILE_PATH, "r")
tkmessagebox.showinfo(self.RULES_MSGBOX_TITLE, file.read())
file.close()
"""Given a menu label and menu option, create a key for fileMenuOptions/helpMenuOptions dicts"""
@staticmethod
def _create_menu_key(menuLabel, menuOption):
return menuLabel + ":" + menuOption.strip(" ")
class LexiconCreator():
"""
Lexicon Creator Class
"""
def __init__(self, master):
self.master = master
self.master.title("Lexicon Creator")
self.master.geometry("250x220")
self.master.resizable(False, False)
foldercreation("Lexicons")
self.createlex = ""
self.wordlabel = Label(
self.master,
text="Word",
)
self.wordlabel.pack()
self.wordT = Text(self.master, height=1, state="disabled")
self.wordT.pack()
self.deflablel = Label(self.master, text="Definition")
self.deflablel.pack()
self.defT = Text(self.master, height=4, state="disabled")
self.defT.pack()
self.cleardb = Button(self.master,
text="Clear Definition",
state="disabled",
command=self.cleardf)
self.cleardb.pack()
self.clearwb = Button(self.master,
text="Clear Word",
state="disabled",
command=self.clearwf)
self.clearwb.pack()
self.addb = Button(self.master,
text="Add",
state="disabled",
command=self.addw)
self.addb.pack()
#menu
self.menu = Menu(self.master)
self.file_menu = Menu(self.menu, tearoff=0)
self.file_menu.add_command(label="Create Lexicon",
accelerator='Ctrl+N',
command=self.create_l)
self.file_menu.add_command(label="Load Lexicon",
accelerator='Ctrl+L',
command=self.load_l)
self.file_menu.add_command(label="Add Word",
accelerator='Ctrl+O',
command=self.addw)
self.file_menu.add_command(label="Close File",
accelerator='Ctrl+F4',
command=self.cfile,
state="disabled")
self.file_menu.add_command(label="Exit",
accelerator='Alt+F4',
command=self.exitmenu)
self.menu.add_cascade(label="File", menu=self.file_menu)
self.edimenu = Menu(self.menu, tearoff=0)
self.edimenu.add_command(label="Reset",
accelerator='Ctrl+Z',
command=self.reset)
self.edimenu.add_command(label="Clear Word",
accelerator='Alt+Z',
command=self.clearwf)
self.edimenu.add_command(label="Clear Definition",
accelerator='Alt+D',
command=self.cleardf)
self.edimenu.add_command(label="Delete Word",
accelerator='Ctrl+D',
command=self.deleteword)
self.menu.add_cascade(label="Edit", menu=self.edimenu)
self.showmenu = Menu(self.menu, tearoff=0)
self.showmenu.add_command(label="Show Lexicon",
accelerator='Ctrl+T',
command=self.showlexicon)
self.menu.add_cascade(label="Show", menu=self.showmenu)
self.about_menu = Menu(self.menu, tearoff=0)
self.about_menu.add_command(label="About",
accelerator='Ctrl+I',
command=aboutmenu)
self.menu.add_cascade(label="About", menu=self.about_menu)
self.help_menu = Menu(self.menu, tearoff=0)
self.help_menu.add_command(label="Help",
accelerator='Ctrl+F1',
command=helpmenu)
self.menu.add_cascade(label="Help", menu=self.help_menu)
self.master.config(menu=self.menu)
self.master.bind('<Control-z>', lambda event: self.reset())
self.master.bind('<Control-o>', lambda event: self.addw())
self.master.bind('<Alt-d>', lambda event: self.cleardf())
self.master.bind('<Alt-z>', lambda event: self.clearwf())
self.master.bind('<Alt-F4>', lambda event: self.exitmenu())
self.master.bind('<Control-F1>', lambda event: helpmenu())
self.master.bind('<Control-i>', lambda event: aboutmenu())
self.master.bind('<Control-t>', lambda event: self.showlexicon())
self.master.bind('<Control-n>', lambda event: self.create_l())
self.master.bind('<Control-l>', lambda event: self.load_l())
self.master.bind('<Control-F4>', lambda event: self.cfile())
self.master.bind('<Control-d>', lambda event: self.deleteword())
def deleteword(self):
""" deletes a word from the loaded or created lexicon"""
if self.createlex == "":
msg.showerror("Error", "No Lexicon")
elif pd.read_csv(str(self.createlex) + str('.csv')).empty:
msg.showerror('Error', "Empty Lexicon")
#else:
#self.word_delete = simpledialog.askstring("Word To Delete", "Enter the word to delete (Case sensitive)", parent=self.master) TODO
def reset(self):
""" clears both word and definition field """
self.wordT.delete(1.0, END)
self.defT.delete(1.0, END)
def cleardf(self):
""" clears the definition text field"""
self.defT.delete(1.0, END)
def clearwf(self):
""" clears the word text field"""
self.wordT.delete(1.0, END)
def showlexicon(self):
""" shows the whole lexicon """
if self.createlex == "":
msg.showerror("Error", "No Lexicon")
elif pd.read_csv(str(self.createlex) + str('.csv')).empty:
msg.showerror('Error', "Empty Lexicon")
else:
df = pd.read_csv(str(self.createlex) + str('.csv'))
df.drop_duplicates(keep="first", inplace=True)
df.replace(r'\r\n', ' ', regex=True, inplace=True)
msg.showinfo("Lexicon Words", str(df))
def cfile(self):
""" closes the lexicon """
if self.createlex == "":
msg.showerror("Error", "No lexicon to close")
else:
self.createlex = ""
self.loadlex = ""
self.wordT.config(state="disable")
self.defT.config(state="disable")
self.addb.config(state="disable")
self.clearwb.config(state="disable")
self.cleardb.config(state="disable")
self.file_menu.entryconfig("Create Lexicon", state="normal")
self.file_menu.entryconfig("Load Lexicon", state="normal")
self.file_menu.entryconfig("Close File", state="disable")
msg.showinfo("SUCCESS", "FILE CLOASED")
def add_word_to_lexicon_file(self):
""" saves a word to the lexicon file """
with open(str(self.createlex) + str('.csv'), 'a+') as f:
thewriter = csv.writer(f)
thewriter.writerow(
[str(self.wordT.get(1.0, END)),
self.defT.get(1.0, END)])
def addw(self):
""" adds word to the lexicon"""
if self.wordT.count(1.0, END) == (1, ) or self.defT.count(
1.0, END) == (1, ):
msg.showerror("Value Error Description Error",
"Enter a word \n Enter a Definition")
self.reset()
else:
self.add_word_to_lexicon_file()
msg.showinfo(
"Word info", "Word: " + str(self.wordT.get(1.0, END)) +
"Definition: " + self.defT.get(1.0, END))
self.reset()
def button_menu_state_change(self):
""" change buttons and menus after lexicon creation or after load"""
self.wordT.config(state="normal")
self.defT.config(state="normal")
self.addb.config(state="normal")
self.clearwb.config(state="normal")
self.cleardb.config(state="normal")
self.file_menu.entryconfig("Close File", state="normal")
self.file_menu.entryconfig("Create Lexicon", state="disabled")
self.file_menu.entryconfig("Load Lexicon", state="disabled")
def createlexiconuserinput(self):
""" create lexicon menu user input"""
self.createlex = simpledialog.askstring(
"NEW LEXICON",
"Enter the name of the new lexicon",
parent=self.master)
while self.createlex is None or (not self.createlex.strip()):
self.createlex = simpledialog.askstring(
"NEW LEXICON",
"Enter the name of the new lexicon",
parent=self.master)
def createlexiconcsv(self):
""" creates the lexicon file """
with open(str(self.createlex) + str(".csv"), 'a+') as d:
thewriter = csv.writer(d)
thewriter.writerow(['Word', 'Definition'])
def create_l(self):
""" creates a lexicon(.csv file)"""
if self.createlex != "":
msg.showerror("Error", "Lexicon already created or loaded")
else:
self.createlexiconuserinput()
if not os.path.exists(self.createlex + str(".csv")):
self.createlexiconcsv()
msg.showinfo("SUCCESS", "THE FILE CREATED SUCCESSFULLY")
self.button_menu_state_change()
else:
msg.showerror("ERROR", "THIS FILE ALREADY EXISTS")
self.createlex = ""
def load_l_user_input(self):
""" load menu user input """
self.loadlex = simpledialog.askstring(
"LOAD LEXICON",
"Enter the name of the lexicon you want to load (Case sensitive)")
while self.loadlex is None:
self.loadlex = simpledialog.askstring(
"LOAD LEXICON",
"Enter the name of the lexicon you want to load (Case sensitive)",
parent=self.master)
def load_l(self):
"""loads a lexicon(.csv file)"""
if self.createlex != "":
msg.showerror("Error", "Lexicon already created or loaded")
else:
self.load_l_user_input()
if str(self.loadlex + ".csv") in os.listdir():
self.createlex = self.loadlex
msg.showinfo("SUCCESS", "THE FILE LOADED SUCCESSFULLY")
self.button_menu_state_change()
else:
msg.showerror(
"ERROR",
"THERE IS NO FILE NAMED " + str(self.loadlex + ".csv"))
def exitmenu(self):
""" exit menu """
if msg.askokcancel("Quit?", "Really quit?"):
self.master.destroy()
def main():
def switchFrame(current_frame, todisplay_frame):
current_frame.grid_forget()
todisplay_frame.grid(row = 0, column = 0, padx = 60, pady = 30)
tk = Tk()
tk.title("BaseConverter")
tk.tk_setPalette(background="#FFFFFF")
menu = Menu(master = tk, bg = "#DDDDDD", activebackground = "#999999")
menu.add_command(label = "Switch to complete converter",
command = lambda : [switchFrame((classicFrame if frameDisplayed.get() == 0 else completeFrame),
(completeFrame if frameDisplayed.get() == 0 else classicFrame)),
frameDisplayed.set((1 if frameDisplayed.get() == 0 else 0)),
menu.entryconfig(index = 1, label = ("Switch to complete converter" if frameDisplayed.get() == 0 else
"Switch to quick converter"))])
tk.config(menu = menu)
frameDisplayed = BooleanVar() # 0 = classic, 1 = complete
frameDisplayed.set(0)
##### classic frame #####
classicFrame = Frame(master = tk, background = "#FFFFFF")
decimalVar = IntVar()
entryDecimal = Entry(master = classicFrame, textvariable = decimalVar, background = "#F8F8F8")
hexaVar = StringVar()
entryHexa = Entry(master = classicFrame, textvariable = hexaVar, background = "#F8F8F8")
binaryVar = StringVar()
entryBinary = Entry(master = classicFrame, textvariable = binaryVar, background = "#F8F8F8")
decimalLabel = Label(master = classicFrame, text = "Decimal")
hexaLabel = Label(master = classicFrame, text = "Hexadecimal")
binaryLabel = Label(master = classicFrame, text = "Binary")
convertButton1 = Button(master = classicFrame, text = "Convert",
command = lambda : conversion(decimalVar, hexaVar, binaryVar),
relief = GROOVE)
classicFrame.grid(row = 0, column = 0, padx = 60, pady = 30)
decimalLabel.grid(row = 0, column = 0, pady = 10, padx = 5, sticky = W)
entryDecimal.grid(row = 0, column = 1, pady = 10)
hexaLabel.grid (row = 1, column = 0, pady = 10, padx = 5, sticky = W)
entryHexa.grid (row = 1, column = 1, pady = 10)
binaryLabel.grid (row = 2, column = 0, pady = 10, padx = 5, sticky = W)
entryBinary.grid (row = 2, column = 1, pady = 10)
convertButton1.grid(row = 3, column = 0, columnspan = 2, pady = 5)
decimalVar.set(0)
hexaVar.set(0)
binaryVar.set(0)
######################### classic frame
##### complete Frame #####
completeFrame = Frame(master = tk)
labelFrom = Label(completeFrame, text = "From base")
fromBaseVar = IntVar()
fromBaseVar.set(0)
baseFrom = Scale(completeFrame, from_ = 2, to = 26, orient = HORIZONTAL, variable = fromBaseVar)
fromVar = StringVar()
fromVar.set("0")
fromEntry = Entry(completeFrame, textvariable = fromVar)
labelFrom.grid(row = 0, column = 0, pady = 10, padx = 5, sticky = W)
baseFrom.grid (row = 0, column = 1, pady = 10, padx = 5)
fromEntry.grid(row = 0, column = 2, pady = 10, padx = 5)
labelTo = Label(completeFrame, text = "To base")
toBaseVar = IntVar()
toBaseVar.set(0)
baseFrom = Scale(completeFrame, from_ = 2, to = 26, orient = HORIZONTAL, variable = toBaseVar)
toVar = StringVar()
toVar.set("0")
toEntry = Entry(completeFrame, textvariable = toVar)
labelTo.grid (row = 1, column = 0, pady = 10, padx = 5, sticky = W)
baseFrom.grid(row = 1, column = 1, pady = 10, padx = 5)
toEntry.grid (row = 1, column = 2, pady = 10, padx = 5)
convertButton2 = Button(master = completeFrame, text = "Convert",
command = lambda : toVar.set(convert(from_n = fromBaseVar.get(), to_m = toBaseVar.get(), number = fromVar.get())),
relief = GROOVE)
convertButton2.grid(row = 2, column = 0, columnspan = 3, pady = 10)
######################### complete frame
tk.mainloop()
class MainWindow:
def __init__(self):
global root
self.provider = None
self.session = None
self.show_image = False
self.original_image = None
self.original_image_name = None
self.main_image = None
self.main_image_orig = None
self.resized = False
self.thumb_prefix = None
self.proxies = None
self.gallery_url = None
self.hist_stack = []
self.fwd_stack = []
self.interrupt = False
self.thumb_url = None
self.image_url = None
self.menu_bar = Menu(root)
self.menu_bar.add_command(label="<< Back",
command=self.back_in_history)
self.menu_bar.add_command(label="Forward >>",
command=self.forward_in_history)
self.menu_bar.add_command(label="View gallery",
command=self.view_gallery_url)
self.menu_bar.add_command(label="Cancel", command=self.calcel)
root.config(menu=self.menu_bar)
frm_top = Frame(root)
self.frm_main = ScrollFrame(root)
frm_status = Frame(root)
frm_center = Frame(self.frm_main.view_port)
frm_left = Frame(self.frm_main.view_port)
frm_right = Frame(self.frm_main.view_port)
frm_caption = Frame(frm_center)
frm_image = Frame(frm_center)
self.btn_prev = LinkButton(self, frm_caption, text="Previous")
self.btn_prev.link = "prev link"
self.btn_prev.pack(side=LEFT)
self.btn_save = Button(frm_caption,
text="Save",
command=self.save_image)
self.btn_save.pack(side=LEFT)
self.btn_next = LinkButton(self, frm_caption, text="Next")
self.btn_next.link = "next link"
self.btn_next.pack(side=LEFT)
self.btn_paste = Button(frm_top,
text="Paste",
command=self.paste_from_clipboard)
self.btn_paste.pack(side=LEFT)
self.btn_update = Button(frm_top,
text="Load image",
command=self.load_image_from_input)
self.btn_update.pack(side=LEFT)
self.sv_url = StringVar()
self.entry_url = Entry(frm_top, textvariable=self.sv_url, width=100)
self.entry_url.bind("<FocusIn>", self.focus_callback)
self.entry_url.bind('<Return>', self.enter_callback)
self.entry_url.pack(side=LEFT)
self.use_proxy = BooleanVar()
self.use_proxy.set(False)
self.use_proxy.trace('w', self.on_use_proxy_change)
self.chk_use_proxy = Checkbutton(frm_top,
text='Use proxy',
variable=self.use_proxy)
self.chk_use_proxy.pack(side=LEFT)
self.sv_proxy = StringVar()
self.entry_proxy = Entry(frm_top,
textvariable=self.sv_proxy,
width=30,
state=DISABLED)
self.entry_proxy.pack(side=LEFT)
self.btn_force = Button(frm_top,
text="Force load",
command=self.force_load_image)
self.btn_force.pack(side=LEFT)
try:
with open("proxy.txt") as f:
self.sv_proxy.set(f.readline().strip())
except BaseException as error:
print(error)
traceback.print_exc()
self.btn_image = Button(frm_image, command=self.resize_image)
self.btn_image.bind("<Button-3>", self.load_original_image_in_thread)
self.btn_image.pack()
self.left_buttons = self.fill_panel(frm_left)
self.right_buttons = self.fill_panel(frm_right)
self.status = StringVar()
self.status_label = Label(frm_status,
bd=1,
relief=SUNKEN,
anchor=W,
textvariable=self.status)
self.status_label.pack(side=LEFT, fill=BOTH, expand=1)
self.status.set('Status Bar')
self.progress_bar = ttk.Progressbar(frm_status,
orient=HORIZONTAL,
length=200,
mode='indeterminate')
root.bind("<FocusIn>", self.focus_callback)
root.bind("<BackSpace>", self.backspace_callback)
root.bind("<space>", self.space_callback)
root.protocol("WM_DELETE_WINDOW", self.on_close)
frm_caption.pack()
frm_image.pack()
frm_left.pack(side=LEFT, fill=BOTH, expand=1)
frm_center.pack(side=LEFT)
frm_right.pack(side=RIGHT, fill=BOTH, expand=1)
frm_top.pack()
self.frm_main.pack(fill=BOTH, expand=1)
frm_status.pack(fill=X)
self.hist_logger = logging.getLogger('history')
self.hist_logger.setLevel(logging.INFO)
self.fh_hist = logging.FileHandler(
os.path.join(LOGS, f'hist_{int(time.time())}.log'))
self.fh_hist.setLevel(logging.INFO)
self.hist_logger.addHandler(self.fh_hist)
def force_load_image(self):
self.load_page_in_thread(self.sv_url.get().strip(), True, True)
def load_image_from_input(self):
self.load_page_in_thread(self.sv_url.get().strip())
def load_page_in_thread(self,
input_url,
remember=True,
ignore_cache=False):
self.set_controls_state(DISABLED)
self.interrupt = False
future = executor.submit(self.load_image_retry, input_url, remember,
ignore_cache)
future.add_done_callback(lambda f: self.set_controls_state(NORMAL))
def load_image_retry(self, input_url, remember, ignore_cache):
global root
try:
err_count = 0
while err_count < MAX_ERRORS:
root.after_idle(self.set_undefined_state)
if self.load_image(input_url, remember, ignore_cache):
break
if self.interrupt:
break
err_count += 1
except BaseException as error:
print("Exception URL: " + input_url)
print(error)
traceback.print_exc()
def load_image(self, input_url, remember, ignore_cache):
global root
if len(input_url) == 0:
return False
root.after_idle(self.sv_url.set, input_url)
self.provider = self.get_provider()
if self.provider is None:
return False
cache_path = os.path.join(CACHE, self.provider.get_domen())
if not os.path.exists(cache_path):
os.mkdir(cache_path)
proxy = self.sv_proxy.get().strip()
if self.use_proxy.get() and len(proxy.strip()) > 0:
self.proxies = {
"http": "http://" + proxy,
"https": "https://" + proxy
}
with open("proxy.txt", "w") as f:
f.write(proxy)
else:
self.proxies = None
http_session = requests.Session()
http_session.headers.update(HEADERS)
ident = self.get_id(input_url)
if ident is None:
print("ident is None")
return False
input_url = "https://" + self.provider.get_host() + "/" + ident
root.after_idle(root.title, input_url)
try:
html = self.get_from_cache(ident)
if ignore_cache or (html is None) or (len(html) == 0):
html = self.get_final_page(ident, input_url, http_session)
if (html is None) or (len(html) == 0):
return False
html = html.decode('utf-8')
if not self.render_page(ident, html, http_session):
return False
if remember and (input_url is not None):
if len(self.hist_stack) == 0 or (input_url !=
self.hist_stack[-1]):
self.hist_stack.append(input_url)
self.hist_logger.info(f'{input_url}\t{self.thumb_url}')
if len(self.fwd_stack) > 0 and (input_url
== self.fwd_stack[-1]):
self.fwd_stack.pop()
else:
self.fwd_stack.clear()
except BaseException as error:
print("Exception URL: " + input_url)
print(error)
traceback.print_exc()
return False
finally:
http_session.close()
return True
def get_final_page(self, ident, input_url, http_session):
global root
response = http_session.get(input_url,
proxies=self.proxies,
timeout=TIMEOUT)
if response.status_code == 404:
print("input_url response.status_code == 404")
return None
html = response.content.decode('utf-8')
if DEBUG:
with open('1.html', 'w') as f:
f.write(html)
# sometimes this functions fails (i don't want to tamper with this)
redirect_url = self.provider.get_redirect_url(html)
if redirect_url is not None:
if len(redirect_url) == 0:
print("(redirect_url is None) or (len(redirect_url) == 0)")
return None
http_session.headers.update({'Referer': input_url})
response = http_session.get(redirect_url,
proxies=self.proxies,
timeout=TIMEOUT)
if response.status_code == 404:
print("redirect_url response.status_code == 404")
return None
html = response.content.decode('utf-8')
if DEBUG:
with open('2.html', 'w') as f:
f.write(html)
pos = html.find('File Not Found')
if pos >= 0:
print("File Not Found: " + input_url)
return None
param = self.provider.get_post_param(html)
if len(param) == 0:
print("len(param) == 0")
return None
post_fields = {'op': 'view', 'id': ident, 'pre': 1, param: 1}
response = http_session.post(redirect_url,
data=post_fields,
proxies=self.proxies,
timeout=TIMEOUT)
if response.status_code == 404:
print("POST: redirect_url response.status_code == 404")
return None
html = response.content
if DEBUG:
with open('3.html', 'wb') as f:
f.write(html)
self.put_to_cache(ident, html)
return html
def render_page(self, ident, html, http_session):
self.thumb_url = get_thumb(html)
if (self.thumb_url is None) or (len(self.thumb_url) == 0):
print("len(thumb_url) == 0")
return False
slash_pos = self.thumb_url.rfind('/')
self.thumb_prefix = self.thumb_url[:slash_pos + 1]
thumb_filename = self.thumb_url[slash_pos + 1:]
dot_pos = thumb_filename.rfind('.')
thumb_filename = thumb_filename[:dot_pos]
self.gallery_url = search('href="([^"]*)">More from gallery</a>', html)
self.reconfigure_prev_button(http_session, html)
self.reconfigure_next_button(http_session, html)
executor.submit(self.reconfigure_left_buttons, html)
executor.submit(self.reconfigure_right_buttons, html)
self.image_url = self.provider.get_image_url(html)
fname = get_filename(self.image_url)
dot_pos = fname.rfind('.')
self.original_image_name = fname[:dot_pos] + '_' + ident
self.original_image = self.get_from_cache(self.original_image_name)
bg_color = 'green'
self.resized = True
if (self.original_image is None) or (len(self.original_image) == 0):
self.original_image = self.get_from_cache(thumb_filename)
self.resized = False
if (self.original_image is None) or (len(self.original_image) == 0):
response = http_session.get(self.thumb_url,
proxies=self.proxies,
timeout=TIMEOUT)
if response.status_code == 404:
print("image_url response.status_code == 404")
return False
self.original_image = response.content
# if DEBUG:
# with open(self.original_image_name, 'wb') as f:
# f.write(self.original_image)
self.put_to_cache(thumb_filename, self.original_image)
bg_color = 'red'
self.resized = False
img = Image.open(io.BytesIO(self.original_image))
w, h = img.size
k = MAIN_IMG_WIDTH / w
img_resized = img.resize((MAIN_IMG_WIDTH, int(h * k)))
root.after_idle(root.title, f"{root.title()} ({w}x{h})")
self.main_image_orig = ImageTk.PhotoImage(img)
self.main_image = ImageTk.PhotoImage(img_resized)
photo_image = self.main_image if self.resized else self.main_image_orig
root.after_idle(self.btn_image.config, {
'image': photo_image,
'background': bg_color
})
if os.path.exists(os.path.join(OUTPUT, self.original_image_name)):
root.after_idle(self.btn_save.config, {'background': 'green'})
return True
def focus_callback(self, event):
self.entry_url.selection_range(0, END)
def enter_callback(self, event):
self.load_image_from_input()
def backspace_callback(self, event):
self.back_in_history()
def space_callback(self, event):
self.forward_in_history()
def on_close(self):
global root
root.update_idletasks()
root.destroy()
self.fh_hist.close()
self.hist_logger.removeHandler(self.fh_hist)
def calcel(self):
self.interrupt = True
def set_undefined_state(self):
global root
self.main_image = None
self.main_image_orig = None
self.original_image = None
self.original_image_name = None
self.btn_image.config(image='', background="SystemButtonFace")
self.btn_save.config(background="SystemButtonFace")
root.title(None)
self.btn_prev.reset()
self.btn_next.reset()
for btn in self.left_buttons:
btn.reset()
for btn in self.right_buttons:
btn.reset()
self.frm_main.scroll_top_left()
def paste_from_clipboard(self):
self.sv_url.set(clipboard.paste())
self.entry_url.selection_range(0, END)
def save_image(self):
if self.original_image is None:
return
filename = self.original_image_name
i = 1
while os.path.exists(os.path.join(OUTPUT, filename)):
filename = f'{self.original_image_name}_{i:04}'
i += 1
with open(os.path.join(OUTPUT, filename), 'wb') as f:
f.write(self.original_image)
self.btn_save.config(background="green")
def on_enter(self, event):
self.status.set(event.widget.link)
def on_leave(self, enter):
self.status.set("")
def fill_panel(self, panel):
buttons = []
for i in range(4):
Grid.columnconfigure(panel, i, weight=1)
for j in range(2):
Grid.rowconfigure(panel, j, weight=1)
btn = LinkButton(self, panel, text=f"({i}, {j})")
btn.link = None
btn.grid(row=i, column=j, sticky=NSEW, padx=PAD, pady=PAD)
buttons.append(btn)
return buttons
def resize_image(self):
self.btn_image.config(
image=(self.main_image_orig if self.resized else self.main_image))
self.resized = not self.resized
self.frm_main.scroll_top_left()
def get_id(self, url):
found = re.search(
r"https?://" + self.provider.get_domen() +
r"\.[a-z]+/(.+?)(?:/|$)", url)
if (found is None) or (found.group(0) is None):
return None
return found.group(1)
def reconfigure_left_buttons(self, html):
tab = get_more_from_author(html)
self.reconfigure_buttons(self.left_buttons, tab)
def reconfigure_right_buttons(self, html):
tab = get_more_from_gallery(html)
self.reconfigure_buttons(self.right_buttons, tab)
def reconfigure_prev_button(self, http_session, html):
url = get_prev_url(html)
if len(url) == 0:
return
ident = self.get_id(url)
img_url = self.thumb_prefix + ident + '_t.jpg'
self.reconfigure_button(http_session, self.btn_prev, url, img_url)
def reconfigure_next_button(self, http_session, html):
url = get_next_url(html)
if len(url) == 0:
return
ident = self.get_id(url)
img_url = self.thumb_prefix + ident + '_t.jpg'
self.reconfigure_button(http_session, self.btn_next, url, img_url)
def reconfigure_button(self, http_session, btn, url, img_url):
global root
filename = get_filename(img_url)
dot_pos = filename.rfind('.')
filename = filename[:dot_pos]
bg_color = "green"
image = self.get_from_cache(filename)
if (image is None) or (len(image) == 0):
image = download_image(http_session, img_url)
self.put_to_cache(filename, image)
bg_color = "red"
if (image is None) or (len(image) == 0):
return
img = Image.open(io.BytesIO(image))
w, h = img.size
k = IMG_WIDTH / w
img_resized = img.resize((IMG_WIDTH, int(h * k)))
photo_image = ImageTk.PhotoImage(img_resized)
if photo_image is None:
return
root.after_idle(btn.set_values, url,
partial(self.load_page_in_thread, url), photo_image,
bg_color)
def reconfigure_buttons(self, buttons, html):
http_session = requests.Session()
http_session.headers.update(HEADERS)
try:
for btn in buttons:
btn.reset()
i = 0
for m in re.finditer('<td>.*?href="(.*?)".*?src="(.*?)".*?</td>',
html, re.MULTILINE | re.DOTALL):
self.reconfigure_button(http_session, buttons[i], m.group(1),
m.group(2))
i += 1
except BaseException as error:
print(error)
traceback.print_exc()
finally:
http_session.close()
def on_use_proxy_change(self, *args):
if self.use_proxy.get():
self.entry_proxy.config(state=NORMAL)
self.entry_proxy.focus_set()
self.entry_proxy.selection_range(0, END)
else:
self.entry_proxy.config(state=DISABLED)
def get_provider(self):
input_url = self.sv_url.get()
pos = input_url.find(ImgRock.DOMEN)
if pos >= 0:
return ImgRock()
pos = input_url.find(ImgView.DOMEN)
if pos >= 0:
return ImgView()
pos = input_url.find(ImgTown.DOMEN)
if pos >= 0:
return ImgTown()
pos = input_url.find(ImgOutlet.DOMEN)
if pos >= 0:
return ImgOutlet()
pos = input_url.find(ImgMaze.DOMEN)
if pos >= 0:
return ImgMaze()
pos = input_url.find(ImgDew.DOMEN)
if pos >= 0:
return ImgDew()
return None
def view_gallery_url(self):
if (self.gallery_url is None) or (len(self.gallery_url) == 0):
return
clipboard.copy(self.gallery_url)
GalleryWindow(self, Toplevel(root))
def back_in_history(self):
if len(self.hist_stack) < 2:
return
self.fwd_stack.append(self.hist_stack.pop())
self.load_page_in_thread(self.hist_stack[-1], False)
def forward_in_history(self):
if len(self.fwd_stack) == 0:
return
self.load_page_in_thread(self.fwd_stack[-1])
def get_from_cache(self, filename):
full_path = os.path.join(CACHE, self.provider.get_domen(), filename)
if not os.path.exists(full_path):
return None
mod_time = time.time()
os.utime(full_path, (mod_time, mod_time))
with open(full_path, 'rb') as f:
return f.read()[::-1]
def put_to_cache(self, filename, data):
if (data is None) or (len(data) == 0):
return
full_path = os.path.join(CACHE, self.provider.get_domen(), filename)
with open(full_path, 'wb') as f:
f.write(data[::-1])
def set_controls_state(self, status):
self.btn_prev.config(state=status)
self.btn_next.config(state=status)
self.btn_update.config(state=status)
self.btn_force.config(state=status)
self.entry_url.config(state=status)
self.btn_paste.config(state=status)
self.chk_use_proxy.config(state=status)
self.entry_proxy.config(state=status)
self.menu_bar.entryconfig("<< Back", state=status)
self.menu_bar.entryconfig("Forward >>", state=status)
for btn in self.left_buttons:
btn.config(state=status)
for btn in self.right_buttons:
btn.config(state=status)
if status == DISABLED:
self.progress_bar.pack(side=LEFT)
self.progress_bar.start()
else:
self.progress_bar.pack_forget()
self.progress_bar.stop()
def load_original_image_in_thread(self, event):
executor.submit(self.load_original_image)
def load_original_image(self):
response = requests.get(self.image_url,
proxies=self.proxies,
timeout=TIMEOUT)
if response.status_code == 404:
print("image_url response.status_code == 404")
return
self.original_image = response.content
# if DEBUG:
# with open(self.original_image_name, 'wb') as f:
# f.write(self.original_image)
self.put_to_cache(self.original_image_name, self.original_image)
bg_color = 'red'
self.resized = True
img = Image.open(io.BytesIO(self.original_image))
w, h = img.size
k = MAIN_IMG_WIDTH / w
img_resized = img.resize((MAIN_IMG_WIDTH, int(h * k)))
root.after_idle(root.title, f"{root.title()} ({w}x{h})")
self.main_image_orig = ImageTk.PhotoImage(img)
self.main_image = ImageTk.PhotoImage(img_resized)
root.after_idle(self.btn_image.config, {
'image': self.main_image,
'background': bg_color
})
class ufoCuratorGui(Frame):
def __init__(self, parent, dir_path=None):
Frame.__init__(self, parent, bg=global_bg)
parent.configure(bg=global_bg) # Set backgound color
parent.grid_columnconfigure(0, weight=1)
parent.grid_rowconfigure(0, weight=1)
self.grid(sticky="NSEW") # Expand frame to all directions
# self.grid_propagate(0)
self.parent = parent
self.dir_path = dir_path
# Initilize GUI
self.initUI()
# If the directory path was given, open it
if dir_path is not None:
self.askdirectory(dir_path=dir_path)
def get_jpg_list(self):
flist = []
for root, subdirs, files in os.walk(self.dir_path):
for fn in files:
if 'P.jpg' in fn:
flist.append(os.path.join(root, fn))
return flist
def askdirectory(self, dir_path=''):
if self.dir_path == '':
old_dir_path = os.getcwd()
else:
old_dir_path = self.dir_path
self.dir_path = dir_path
if self.dir_path == '':
self.dir_path = tkFileDialog.askdirectory(title='Select Folder',
initialdir=old_dir_path)
if self.dir_path == '':
self.dir_path = old_dir_path
else:
self.imagelist = self.get_jpg_list()
self.update_listbox(self.imagelist)
# Update dir label
self.parent.wm_title("ufoCurator: " + self.dir_path)
if len(self.imagelist) > 0:
self.move_top(0) # Move listbox cursor to the top
def move_top(self, event):
if self.listbox is not self.parent.focus_get():
self.listbox.focus()
self.listbox.activate(0)
self.listbox.selection_clear(0, END)
self.listbox.selection_set(0)
self.listbox.see(0)
self.update_image(0)
def update_listbox(self, bin_list):
""" Updates the listbox with the current entries.
"""
self.listbox.delete(0, END)
for line in sorted(bin_list):
self.listbox.insert(END, line)
def update_image(self, status):
if self.dir_path is not None:
if len(self.imagelist) > 0:
self.current_image = self.listbox.get(
self.listbox.curselection()[0])
img_path = self.current_image # os.path.join(self.dir_path, self.current_image)
imgdata = ImageTk.PhotoImage(file=img_path)
self.imagelabel = Label(self, image=imgdata)
self.imagelabel.image = imgdata
self.imagelabel.grid(row=3, column=3, rowspan=4, columnspan=3)
def show_about(self):
tkMessageBox.showinfo(
"About", """ufoCurator version: """ + str(version) + """
Simple tool to clean out bad data from a UFO dataset.\n
Usage: select a folder from the File menu, click Clean.\n
Bad data will be moved to a folder 'bad',\n
You can also manually move files to 'bad' or back again\n
""")
def initUI(self):
self.parent.title("UFO Curator")
# Configure the style of each element
s = Style()
s.configure("TButton",
padding=(0, 5, 0, 5),
font='serif 10',
background=global_bg)
s.configure('TLabelframe.Label',
foreground=global_fg,
background=global_bg)
s.configure('TLabelframe',
foreground=global_fg,
background=global_bg,
padding=(3, 3, 3, 3))
s.configure("TRadiobutton", foreground=global_fg, background=global_bg)
s.configure("TLabel", foreground=global_fg, background=global_bg)
s.configure("TCheckbutton", foreground=global_fg, background=global_bg)
s.configure("Vertical.TScrollbar",
background=global_bg,
troughcolor=global_bg)
self.columnconfigure(0, pad=3)
self.columnconfigure(1, pad=3)
self.columnconfigure(2, pad=3)
self.rowconfigure(0, pad=3)
self.rowconfigure(1, pad=3)
# Make menu
self.menuBar = Menu(self.parent)
self.parent.config(menu=self.menuBar)
# File menu
fileMenu = Menu(self.menuBar, tearoff=0)
fileMenu.add_command(label="Open folder", command=self.askdirectory)
fileMenu.add_separator()
fileMenu.add_command(label="Exit", command=self.quitApplication)
self.menuBar.add_cascade(label="File", underline=0, menu=fileMenu)
self.menuBar.entryconfig("File", state="normal")
# Help Menu
helpMenu = Menu(self.menuBar, tearoff=0)
helpMenu.add_command(label="About", command=self.show_about)
self.menuBar.add_cascade(label="Help", underline=0, menu=helpMenu)
# actions panel
self.action_panel = LabelFrame(self, text=' Actions')
self.action_panel.grid(row=0,
column=0,
sticky="W",
padx=2,
pady=5,
ipadx=5,
ipady=5)
curate_button = StyledButton(self.action_panel,
text="Clean",
width=5,
command=lambda: self.curateData())
curate_button.grid(row=2, column=7, rowspan=2)
moveone_button = StyledButton(self.action_panel,
text="Clean One",
width=9,
command=lambda: self.moveone())
moveone_button.grid(row=2, column=8, rowspan=2)
moveback_button = StyledButton(self.action_panel,
text="Move Back",
width=9,
command=lambda: self.moveback())
moveback_button.grid(row=2, column=9, rowspan=2)
# Listbox
self.scrollbar = Scrollbar(self)
self.listbox = Listbox(self,
width=47,
yscrollcommand=self.scrollbar.set,
exportselection=0,
activestyle="none",
bg=global_bg,
fg=global_fg)
self.listbox.config(height=37) # Listbox size
self.listbox.grid(row=4,
column=0,
rowspan=7,
columnspan=2,
sticky="NS") # Listbox position
self.scrollbar.grid(row=4, column=2, rowspan=7,
sticky="NS") # Scrollbar size
self.listbox.bind('<<ListboxSelect>>', self.update_image)
self.scrollbar.config(command=self.listbox.yview)
# IMAGE
if getattr(sys, 'frozen', False) is True:
# frozen
dir_ = os.path.dirname(sys.executable)
else:
# unfrozen
dir_ = os.path.dirname(os.path.realpath(__file__))
try:
# Show the TV test card image on program start
noimage_data = open(os.path.join(dir_, 'noimage.bin'), 'rb').read()
noimage = PhotoImage(data=noimage_data)
except:
noimage = None
self.imagelabel = Label(self, image=noimage)
self.imagelabel.image = noimage
self.imagelabel.grid(row=3, column=3, rowspan=4, columnspan=3)
def quitApplication(self):
print('quitting')
quitApp()
def curateData(self):
if self.dir_path is not None:
log.info(self.dir_path)
doCuration(self.dir_path)
self.imagelist = self.get_jpg_list()
self.update_listbox(self.imagelist)
def moveone(self):
if self.dir_path is not None:
self.current_image = self.listbox.get(
self.listbox.curselection()[0])
img_path = self.current_image
moveOne(self.dir_path, img_path, False)
self.imagelist = self.get_jpg_list()
self.update_listbox(self.imagelist)
def moveback(self):
if self.dir_path is not None:
self.current_image = self.listbox.get(
self.listbox.curselection()[0])
img_path = self.current_image
moveOne(self.dir_path, img_path, True)
self.imagelist = self.get_jpg_list()
self.update_listbox(self.imagelist)
class Notepad:
'''A simple notepad application'''
def __init__(self, master):
'''
Parameters
----------
master : object
tkinter root window object
'''
self.master = master
self.master.title('Untitled - Notepad')
self.master.geometry('800x600+500+400')
self.master.protocol("WM_DELETE_WINDOW", self.exit_app)
self._current_file_path = None
# Menu bar fields
menubar = Menu(self.master)
# File menu
self.create_file_menu_fields(menubar)
# Edit menu
self.create_edit_menu_fields(menubar)
# Tools menu
self.create_tools_menu_fields(menubar)
# Help menu
self.create_help_menu_fields(menubar)
# Adds menu bar to the GUI
self.master.config(menu=menubar)
# Text fields
self._text = scrolledtext.ScrolledText(self.master, undo=True,\
background='white')
self._text.place(x=0, y=0, relwidth=1, relheight=1)
self._text.bind('<<Selection>>', self.selection_event_handler)
self._text.bind('<Control-x>', self.cut_text)
self._text.bind('<Control-c>', self.copy_text)
self._text.bind('<Control-v>', self.paste_text)
self._text.bind('<Control-a>', self.select_all)
# When path is given as an argument
if len(sys.argv) > 1 and sys.argv[1] and os.path.isfile(sys.argv[1]):
self.open_file(file_path=sys.argv[1])
def create_file_menu_fields(self, menubar):
'''Creates "file" menu fields.
Parameters
----------
menubar : object
tkinter menu object
'''
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='New', command=self.new_file)
filemenu.entryconfig('New', accelerator='Ctrl+N')
self.master.bind('<Control-n>', self.new_file)
filemenu.add_command(label='Open', command=self.open_file)
filemenu.entryconfig('Open', accelerator='Ctrl+O')
self.master.bind('<Control-o>', self.open_file)
filemenu.add_command(label='Save', command=self.save_file)
filemenu.entryconfig('Save', accelerator='Ctrl+S')
self.master.bind('<Control-s>', self.save_file)
filemenu.add_command(label='Save As', command=self.save_as_file)
filemenu.add_separator()
filemenu.add_command(label='Exit', command=self.exit_app)
menubar.add_cascade(label='File', menu=filemenu)
def create_edit_menu_fields(self, menubar):
'''Creates "edit" menu fields.
Parameters
----------
menubar : object
tkinter menu object
'''
self._editmenu = Menu(menubar, tearoff=0)
self._editmenu.add_command(label='Cut', command=self.cut_text)
self._editmenu.entryconfig('Cut', accelerator='Ctrl+X')
self._editmenu.add_command(label='Copy', command=self.copy_text)
self._editmenu.entryconfig('Copy', accelerator='Ctrl+C')
self._editmenu.add_command(label='Paste', command=self.paste_text)
self._editmenu.entryconfig('Paste', accelerator='Ctrl+V')
self._editmenu.add_command(label='Delete', command=self.delete_text)
menubar.add_cascade(label='Edit', menu=self._editmenu)
self.disable_edit_labels()
def create_tools_menu_fields(self, menubar):
'''Creates "tools" menu fields.
Parameters
----------
menubar : object
tkinter menu object
'''
toolsmenu = Menu(menubar, tearoff=0)
toolsmenu.add_command(label='Finder', command=self.open_finder)
toolsmenu.entryconfig('Finder', accelerator='Ctrl+F')
self.master.bind('<Control-f>', self.open_finder)
menubar.add_cascade(label='Tools', menu=toolsmenu)
def create_help_menu_fields(self, menubar):
'''Creates "help" menu fields.
Parameters
----------
menubar : object
tkinter menu object
'''
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About notepad', command=self.view_about)
menubar.add_cascade(label='Help', menu=helpmenu)
def new_file(self, event=None):
'''Clears text field to be blank.
Parameters
----------
event : object
A bind key event
'''
# Suggests to save a file if changes were made
self.check_changes_in_text()
self._text.delete('1.0', 'end')
self._current_file_path = None
self.master.title('Untitled - Notepad')
self._text.edit_modified(0)
def open_file(self, event=None, file_path=None):
'''Opens selected by user file.
Parameters
----------
event : object
A bind key event
file_path : string
File\'s path to open
'''
# Suggests to save a file if changes were made
self.check_changes_in_text()
if not file_path:
# Asks user to select which file to open
file_path = filedialog.askopenfilename(filetypes=\
(('Text files', '*.txt'), ('All files', '*.*')))
if file_path:
file_handler = open(file_path, 'r')
if file_handler:
text_read = file_handler.read()
file_handler.close()
self._text.delete('1.0', 'end')
self._text.insert('1.0', text_read)
self.change_title(file_path)
self._current_file_path = file_path
self._text.edit_modified(0)
def save_file(self, event=None):
'''Saves current text to it\'s file.
Parameters
----------
event : object
A bind key event
'''
if self._current_file_path:
# When existing file is open, save is made without asking for path again
file_handler = open(self._current_file_path, 'w')
if file_handler:
text_to_save = str(self._text.get('1.0', 'end'))
file_handler.write(text_to_save)
file_handler.close()
self.change_title(self._current_file_path)
self._text.edit_modified(0)
else:
# When this is a new file, never saved, asks a user for a path
self.save_as_file()
def save_as_file(self):
'''Saves current text to a selected file'''
# Gets file path from a user
file_path = filedialog.asksaveasfilename(defaultextension='.txt',\
filetypes=(('Text files', '*.txt'), ('All files', '*.*')))
if file_path:
# When file path was selected, calls save function on that path
self._current_file_path = file_path
self.save_file()
def exit_app(self):
'''Closes the application'''
self.check_changes_in_text()
self.master.quit()
def change_title(self, file_path):
'''Changes application\'s title when the file with the current
text exists.
Parameters
----------
file_path : string
File\'s path
'''
file_name = os.path.basename(file_path)
self.master.title(file_name + ' - Notepad')
def check_changes_in_text(self):
'''Checks whether the text in the text field has been modified'''
if self._text.edit_modified():
# When text was modified
reply = messagebox.askyesno('Save changes',\
'The file has been modified.\nDo you want to save the changes?')
if reply:
self.save_file()
def enable_edit_labels(self):
'''Enables "edit" menu labels when text is selected'''
# Enables Cut, Copy, Paste and Delete labels
self._editmenu.entryconfig('Cut', state='normal')
self._editmenu.entryconfig('Copy', state='normal')
self._editmenu.entryconfig('Delete', state='normal')
if self.master.clipboard_get():
self._editmenu.entryconfig('Paste', state='normal')
def disable_edit_labels(self):
'''Disables "edit" menu labels when text is not selected'''
# Disables Cut, Copy, Paste and Delete labels
self._editmenu.entryconfig('Cut', state='disabled')
self._editmenu.entryconfig('Copy', state='disabled')
self._editmenu.entryconfig('Delete', state='disabled')
if not self.master.clipboard_get():
self._editmenu.entryconfig('Paste', state='disabled')
def selection_event_handler(self, event):
'''Handles event when a text is selected/deselected.
Parameters
----------
event : object
A selection bind event
'''
if self._text.tag_ranges('sel'):
# There is selection
self.enable_edit_labels()
else:
self.disable_edit_labels()
def cut_text(self, event=None):
'''Cuts selected text.
Parameters
----------
event : object
A bind key event
'''
self.copy_text()
self.delete_text()
return 'break'
def copy_text(self, event=None):
'''Copies selected text to the clipboard.
Parameters
----------
event : object
A bind key event
'''
self.master.clipboard_clear()
text_to_copy = self._text.get('sel.first', 'sel.last')
self.master.clipboard_append(text_to_copy)
return 'break'
def paste_text(self, event=None):
'''Pastes a text from the clipboard.
Parameters
----------
event : object
A bind key event
'''
text_to_paste = self.master.clipboard_get()
self._text.insert('insert', text_to_paste)
return 'break'
def delete_text(self):
'''Deletes selected text'''
self._text.delete('sel.first', 'sel.last')
self.disable_edit_labels()
return 'break'
def view_about(self):
'''Opens a new window with description of the application'''
about_window = Toplevel(self.master)
about_window.wm_title('Notepad - About Notepad')
about_window.resizable(False, False)
self.define_window_geometry(about_window, 500, 105)
Label(about_window, justify='left', text='\n'\
+ 'This application is a basic version of Windows 10 Notepad, and '\
+ 'can be run on Unix.'\
+ '\nWritten in Python3 as a personal project.'\
+ '\n\nMade by Eugeny Khanchin =]').pack(ipady=10)
def select_all(self, event=None):
'''Selects all text inside the text widget.
Parameters
----------
event : object
A bind key event
'''
self._text.tag_add('sel', 1.0, 'end')
return 'break'
def open_finder(self, event=None):
'''Creates and opens a finder window that allows to find a text
inside the text widget.
Parameters
----------
event : object
A bind key event
'''
finder_window = Toplevel(self.master)
finder_window.wm_title('Notepad - Finder')
self.define_window_geometry(finder_window, 374, 115)
finder_window.takefocus = True
finder_window._current_text = None
Label(finder_window, text='Text to find:').place(x=10, y=10)
finder_window._finder_entry = ttk.Entry(finder_window, width=50)
finder_window._finder_entry.place(x=10, y=30)
finder_window._find_button = ttk.Button(finder_window, text='Find',\
command=lambda: self.find_text(finder_window))
finder_window._find_button.place(x=117, y=60, width=60)
finder_window._cancel_button = ttk.Button(finder_window, text='Cancel',\
command=lambda: finder_window.destroy())
finder_window._cancel_button.place(x=197, y=60, width=60)
def find_text(self, finder_window):
'''Finds text inside the text widget.
Parameters
----------
finder_window : object
tkinter toplevel window object
'''
text = finder_window._finder_entry.get()
if text != finder_window._current_text:
# When given text is different from the previous search
finder_window._generator = self.find_next_generator(text)
finder_window._current_text = text
if finder_window._generator:
try:
# Gets next value from the generator
(pos, countVar) = next(finder_window._generator)
except:
# Recreates again the generator when it's exhausted
finder_window._generator = self.find_next_generator(text)
messagebox.showinfo('Finder Info', 'No more matchings!')
finder_window.lift()
finder_window.focus_force()
else:
# Select the matching word in the Text widget
self._text.tag_remove('sel', '1.0', 'end')
self._text.tag_add('sel', pos, f'{pos} + {countVar}c')
self._text.see(pos)
def find_next_generator(self, text):
'''Gets a generator that creates an iter list of indexes of a
matched text.
Parameters
----------
text : string
Text to be found
'''
start = '1.0'
countVar = StringVar()
pos = self._text.search(text, start, stopindex='end', count=countVar)
while pos:
yield (pos, countVar.get())
start = f'{pos} + {countVar.get()}c'
pos = self._text.search(text, start, stopindex='end', count=countVar)
def define_window_geometry(self, window, width, height):
'''Defines given window\'s geometry.
Parameters
----------
window : object
tkinter window object
width : integer
Window\'s width
height : integer
Window\'s height
'''
x = self.master.winfo_x()
y = self.master.winfo_y()
x += 10
y += 10
window.geometry(f'{width}x{height}+{x}+{y}')
class MyFirstGUI:
fileData = RejectingDict()
last_statusbar_value = ''
def __init__(self, master):
self.master = master
master.title("Сертификаты из ТТН")
master.geometry("300x100")
master.grid_columnconfigure(index=0, minsize=350, weight=5)
#master.grid_columnconfigure(index = 1, weight = 0)
menu = Menu(master, tearoff=0)
#need to store submenu to be able to address it from others subs
self.submenu2 = Menu(master, tearoff=0)
self.submenu3 = Menu(master, tearoff=0)
self.submenu4 = Menu(master, tearoff=0)
self.menubar = Menu(menu, tearoff=0)
menu.add_command(label="Open", command=self.open)
menu.add_separator()
menu.add_command(label="Exit", command=master.destroy)
#cascade index = 0
self.menubar.add_cascade(label="File", menu=menu, state="normal")
self.submenu2.add_command(label="Copies",
command=self.copies,
state="disabled")
#cascade index = 1
self.menubar.add_cascade(label="Operations", menu=self.submenu2)
self.submenu4.add_command(label="Options", command=self.options)
#cascade index = 2
self.menubar.add_cascade(label="Settings", menu=self.submenu4)
self.commandAbout = self.submenu3.add_command(label="About",
command=self.about)
#cascade index = 3
self.menubar.add_cascade(label="Help", menu=self.submenu3)
self.lbMain = Listbox(
master,
selectmode='extended',
state="disabled",
width=50, #width in characters
height=5 #number of lines
)
self.scrollbar = Scrollbar(master, orient='vertical')
self.lbMain.config(yscrollcommand=self.scrollbar.set)
self.scrollbar.config(command=self.lbMain.yview)
self.scrollbar.grid(
row=0,
column=0,
ipady=0,
sticky='e' # just to the right side East
)
self.lbMain.grid(
row=0,
column=0,
sticky='n, s, e, w' #to all sides
)
# status bar
status_frame = Frame(master, height=10)
self.status = Label(status_frame, text="this is the status bar")
self.status.pack(fill="both", expand=True)
status_frame.grid(row=1, column=0)
self.lbMain.bind('<<ListboxSelect>>', self.on_lbSelect)
self.submenu3.bind('<<MenuSelect>>', self.about_status)
self.submenu3.bind('<Enter>', self.about_status)
self.submenu4.bind('<<MenuSelect>>', self.options_status)
self.submenu4.bind('<Enter>', self.options_status)
self.submenu3.bind('<Leave>', self.status_leave)
self.submenu4.bind('<Leave>', self.status_leave)
master.config(menu=self.menubar)
def about_status(self, event):
self.last_statusbar_value = self.status['text']
self.status['text'] = 'About'
print(event.widget)
def options_status(self, event):
self.last_statusbar_value = self.status['text']
self.status['text'] = 'Options'
print(event.widget)
def status_leave(self, event):
self.status['text'] = self.last_statusbar_value
def about(self):
messagebox.showinfo(
title="About",
message="Program reads TTNs from Excel files " +
"and prints either quality certificates Consignee-wise or prepares"
+ " PDFs with complacency certificates on the same basis")
def options(self):
pass
def open(self):
print("Opening files")
filename = Dialog.askopenfilename(
initialdir=os.path.dirname(__file__),
title="Файлы с ТТН",
#need to leave comma to build 1-x tuple
filetypes=(("Excel files", "*.xls"), ),
multiple=True)
if len(filename) == 0: return
for nm in filename:
try:
ob = TTNReader(nm)
self.fileData[ob.TTN_data["TTN_Number"]] = ob
#filling in the listbox
if self.lbMain.size() == 0:
self.lbMain.config(state='normal')
self.lbMain.insert('end', str(ob.TTN_data["TTN_Number"]))
except:
continue
def on_lbSelect(self, evt):
if len(self.lbMain.curselection()) != 0:
self.submenu2.entryconfig('Copies', state="normal")
else:
self.submenu2.entryconfig('Copies', state="disabled")
def copies(self):
"""
Prepares PDFs with inscriptions
"""
for ttn in self.lbMain.curselection():
print(self.fileData[int(self.lbMain.get(ttn))].TTN_data["path"])
class SortResultsWindow:
def __init__(self, parent: Tk, data: List[List[str]], filename: str):
self.parent = parent
self.data = data
self.sorted_data = []
self.sorted_data_headings = []
self.parent.title(filename)
self.parent.grid_columnconfigure(0, weight=1)
self.parent.grid_rowconfigure(0, weight=1)
self.main_frame = ttk.Frame(self.parent, padding=(3, 3, 12, 12))
self.main_frame.grid(column=0, row=0, sticky=(N, S, E, W))
self.main_frame.grid_columnconfigure(0, weight=1)
self.main_frame.grid_rowconfigure(0, weight=1)
self.main_frame.grid_rowconfigure(1, weight=1)
# Initialise the treeview
self.render_data()
self.sort_opts_moved_frame = ttk.Frame(self.main_frame)
self.sort_opts_moved_frame.grid(column=0, row=1, sticky=(N, S, E, W))
# self.sort_opts_moved_frame_title_label.grid(column=0, row=0)
self.sort_opts_moved_frame_message_label = ttk.Label(
self.sort_opts_moved_frame,
text=
"Sorting options have moved to the file menu!\nTo access the sorting options, go to File > Sort By."
)
# self.sort_opts_moved_frame_message_label.grid(column=0, row=1)
self.sort_opts_moved_frame_message_label.place(relx=0.5,
rely=0.5,
anchor=CENTER)
"""
self.sort_by_frame = ttk.Frame(self.main_frame)
self.sort_by_frame.grid(column=0, row=1, sticky=(N, S, E, W))
self.sort_by_frame_label = ttk.Label(self.sort_by_frame, text="Sort by:")
self.sort_by_frame_label.grid(column=0, row=0)
self.sort_by_frame_ability_button = ttk.Button(self.sort_by_frame, text="Ability", command=self.sort_by_ability)
self.sort_by_frame_ability_button.grid(column=0, row=1)
self.sort_by_frame_mixed_ability_button = ttk.Button(self.sort_by_frame, text="Mixed Ability",
command=self.sort_by_mixed_ability)
self.sort_by_frame_mixed_ability_button.grid(column=1, row=1)
"""
# self.main_frame.grid_rowconfigure(0, weight=1)r
# self.main_frame.grid_rowconfigure(2, weight=1)
# self.main_frame.grid_columnconfigure(0, weight=1)
# self.main_frame.grid_columnconfigure(2, weight=1)
self.parent.minsize(width=480, height=270)
# The menu bar
self.menubar = Menu(parent)
# File menu
self.filemenu = Menu(self.menubar, name="file", tearoff=0)
self.filemenu.add_command(label="Export Results...",
underline=0,
accelerator="Command-s",
command=self.export_results,
state="disabled")
self.filemenu.add_separator()
# self.filemenu.add_command(label="Revert To Original List", underline=0, accelerator="Command-z",
# command=self.revert_to_original)
self.sortbymenu = Menu(self.filemenu, tearoff=0)
self.abilitytextvar = StringVar(master=self.parent, value="none")
self.sortbymenu.add_radiobutton(label="None",
variable=self.abilitytextvar,
value="none",
underline=0,
command=self.revert_original)
self.sortbymenu.add_radiobutton(label="Ability",
variable=self.abilitytextvar,
value="ability",
underline=0,
command=self.sort_by_ability)
self.sortbymenu.add_radiobutton(label="Mixed Ability...",
variable=self.abilitytextvar,
value="mixed",
underline=0,
command=self.sort_by_mixed_ability)
self.filemenu.add_cascade(label="Sort By",
menu=self.sortbymenu,
underline=0)
# Initially disable saving as there is currently no data to export
self.parent.bind_all("<Command-s>", self.export_results)
# self.parent.bind_all("<Command-z>", self.revert_to_original)
self.menubar.add_cascade(label="File", menu=self.filemenu, underline=0)
# View menu
self.viewmenu = Menu(self.menubar, name="view", tearoff=0)
self.menubar.add_cascade(menu=self.viewmenu, label="View", underline=0)
# Window menu
self.windowmenu = Menu(self.menubar, name="window", tearoff=0)
self.menubar.add_cascade(menu=self.windowmenu,
label="Window",
underline=0)
# Help menu
self.helpmenu = Menu(self.menubar, name="help", tearoff=0)
self.menubar.add_cascade(label="Help", menu=self.helpmenu, underline=0)
self.parent.config(menu=self.menubar)
self.algorithm = SortingAlgorithm(data)
def treeview_sort_column(self, tv, col, reverse):
l = [(tv.set(k, col), k) for k in tv.get_children('')]
l.sort(reverse=reverse)
# rearrange items in sorted positions
for index, (val, k) in enumerate(l):
tv.move(k, '', index)
# reverse sort next time
tv.heading(col,
command=lambda _col=col: self.treeview_sort_column(
tv, _col, not reverse))
def export_results(self, event=None):
ftypes = [
# TODO: Reimplement XLS support
# ("Legacy Excel worksheet", "*.xls"),
# TODO: Implement XLSX support
# xlwt does not support xlsx files for now
# ("Excel workbook", "*.xlsx"),
("Comma-separated value file", "*.csv"),
("Tab-separated value file", "*.tsv")
]
filename = asksaveasfilename(parent=self.parent,
title="Save results as",
filetypes=ftypes,
initialfile="student_grouper_results")
with open(filename, "w") as file:
fileext = Utils.get_file_ext(filename)
if fileext == "xls":
workbook = xlwt.Workbook()
sheet = workbook.add_sheet("Student Grouper Results")
print("Sorted data headings:", self.sorted_data_headings)
# print("Sorted data:", list(self.sorted_data))
for index, item in enumerate(self.sorted_data):
print("Index:", index)
print("Item:", item)
row = sheet.row(index)
for itemindex, nesteditem in enumerate(item):
print("Item index:", itemindex)
print("Nested item:", nesteditem)
print("Nested item type:", type(nesteditem))
print("Index:", index)
print("Item:", item)
row.write(itemindex, nesteditem)
workbook.save(file)
elif fileext == "csv":
file_writer = csv.writer(file)
file_writer.writerow(list(self.sorted_data_headings))
file_writer.writerows(list(self.sorted_data))
elif fileext == "tsv":
file_writer = csv.writer(file, delimiter="\t")
file_writer.writerow(list(self.sorted_data_headings))
file_writer.writerows(list(self.sorted_data))
else:
print("File extension {} is not supported!".format(fileext))
def revert_original(self, event=None):
"""
Reverts to the original list of data
:param event: The event of a menu item
"""
self.render_data(event, destroy_tree_view=True)
def render_data(self, event=None, destroy_tree_view=False):
"""
Renders the data as a table
:param event: The event of a menu item
:param destroy_tree_view: Whether to destroy the tree view
"""
if destroy_tree_view and self.tree_view is not None:
self.tree_view.destroy()
self.tree_view = ttk.Treeview(self.main_frame,
columns=("name", "ability", "gender"),
show="headings")
self.tree_view.grid(column=0, row=0, sticky=(N, S, E, W))
for col in self.tree_view["columns"]:
self.tree_view.heading(
col,
text=col.capitalize(),
command=lambda _col=col: self.treeview_sort_column(
self.tree_view, _col, False))
self.tree_view.column("name", width=150)
self.tree_view.column("gender", width=60)
self.tree_view.column("ability", width=70)
for data_item in self.data:
name = data_item[0]
ability = ""
gender = ""
if data_item[1].lower() in ["l", "low"]:
ability = "Low"
elif data_item[1].lower() in ["m", "medium"]:
ability = "Medium"
elif data_item[1].lower() in ["h", "high"]:
ability = "High"
if data_item[2].lower() in ["f", "female"]:
gender = "Female"
elif data_item[2].lower() in ["m", "male"]:
gender = "Male"
self.tree_view.insert("", "end", values=(name, ability, gender))
def sort_by_ability(self, event=None):
if event is not None:
print(event)
return
# Use sorting algorithm for ability
print("Data in algorithm class:", self.algorithm.data)
print("Low data in algorithm class:", self.algorithm.low)
print("Middle data in algorithm class:", self.algorithm.middle)
print("High data in algorithm class:", self.algorithm.high)
sorted_list = self.algorithm.sort_ability()
# Reinitialise the tree view
self.tree_view.destroy()
self.tree_view = ttk.Treeview(self.main_frame,
columns=("high", "medium", "low"),
show="headings")
self.tree_view.grid(column=0, row=0, sticky=(N, S, E, W))
for column in self.tree_view["columns"]:
self.tree_view.heading(column,
text="{} ability".format(
column.capitalize()))
# Code for displaying data in columns
names = map(list, zip(*sorted_list))
# Insert the data into the tree view
for name_list in names:
self.tree_view.insert("", "end", values=tuple(name_list))
# And set the sorted data to the result of the sorting algorithm
self.sorted_data = map(list, zip(*sorted_list))
self.sorted_data_headings = ["High", "Medium", "Low"]
# Reenable export result menu item
self.filemenu.entryconfig(0, state="normal")
def sort_by_mixed_ability(self, event=None):
if event is not None:
print(event)
return
groups = askinteger("Prompt", "Enter the number of groups:")
# askinteger returns None if the user pressed the cancel button or escaped the dialog
if groups is not None:
if groups <= 0:
showerror(
title="Error",
message="Please enter a number which is higher than 0!")
self.sort_by_mixed_ability()
else:
print("Data in algorithm class:", self.algorithm.data)
print("Low data in algorithm class:", self.algorithm.low)
print("Middle data in algorithm class:", self.algorithm.middle)
print("High data in algorithm class:", self.algorithm.high)
sorted_mixed_list = self.algorithm.sort_mixed(groups)
print(sorted_mixed_list)
self.tree_view.destroy()
columns = tuple("group-{}".format(i)
for i in range(1, groups + 1))
self.tree_view = ttk.Treeview(self.main_frame,
columns=columns,
show="headings")
self.tree_view.grid(column=0, row=0, sticky=(N, S, E, W))
for i in range(1, groups + 1):
self.tree_view.heading("group-{}".format(i),
text="Group {}".format(i))
# names = [tuple(list(x)[0]) for x in zip(*sorted_mixed_list)]
names = map(list, zip(*sorted_mixed_list))
for name in names:
self.tree_view.insert("", "end", values=tuple(name))
self.sorted_data = map(list, zip(*sorted_mixed_list))
self.sorted_data_headings = [
"Group {}".format(i) for i in range(1, groups + 1)
]
# Reenable export result menu item
self.filemenu.entryconfig(0, state="normal")
def initUI(self):
def rainbow():
arduino.write(struct.pack('>BBBB', 2, 1, 0, 0))
time.sleep(.1)
arduino.flush()
def baw():
arduino.write(struct.pack('>BBBB', 2, 2, 0, 0))
time.sleep(.1)
arduino.flush()
def fire1():
arduino.write(struct.pack('>BBBB', 2, 3, 0, 0))
time.sleep(.1)
arduino.flush()
def fire2():
arduino.write(struct.pack('>BBBB', 2, 7, 0, 0))
time.sleep(.1)
arduino.flush()
def lava():
arduino.write(struct.pack('>BBBB', 2, 5, 0, 0))
time.sleep(.1)
arduino.flush()
def forest():
arduino.write(struct.pack('>BBBB', 2, 6, 0, 0))
time.sleep(.1)
arduino.flush()
def ocean():
arduino.write(struct.pack('>BBBB', 2, 4, 0, 0))
time.sleep(.1)
arduino.flush()
def police():
arduino.write(struct.pack('>BBBB', 2, 8, 0, 0))
time.sleep(.1)
arduino.flush()
def party():
arduino.write(struct.pack('>BBBB', 2, 9, 0, 0))
time.sleep(.1)
arduino.flush()
def turnoff():
arduino.write(struct.pack('>BBBB', 2, 0, 0, 0))
time.sleep(.1)
arduino.flush()
def customColor():
color = askcolor()
if color:
red = int(color[0][0])
green = int(color[0][1])
blue = int(color[0][2])
colors = (4, red, green, blue)
print(colors)
arduino.write(struct.pack('>BBBB', 4, red, green, blue))
time.sleep(.1)
arduino.flush()
def setbright():
arduino.write(struct.pack('>BBBB', 1, 2, brightslider.get(), 0))
time.sleep(.1)
arduino.flush()
def setspeed():
arduino.write(struct.pack('>BBBB', 1, 4, speedslider.get(), 0))
time.sleep(.1)
arduino.flush()
def savesettings():
arduino.write(struct.pack('>BBBB', 3, 0, 0, 0))
time.sleep(.1)
arduino.flush()
def invertrotation():
arduino.write(struct.pack('>BBBB', 1, 3, 0, 0))
time.sleep(.1)
arduino.flush()
def makeFunc(x):
return lambda: self.openPort(x)
active = True
pal = 0
bright = 0
speed = 0
arduino.write(struct.pack('>BBBB', 9, 1, 0, 0))
arduino.timeout = 5
print(com)
try:
got = arduino.readline()[:-2].decode('utf-8').split()
if got[4] == 'arduino':
connected = True
pal = got[0]
bright = got[1]
speed = got[2]
print(pal)
print(bright)
print(speed)
time.sleep(.1)
if got[3] == '9':
active = False
else:
connected = False
print('Not connected to an LED strip')
except:
connected = False
arduino.flush()
if connected == True:
status = com + ' - ' + got[5]
else:
status = "Not connected to an LED strip"
t = 0
self.master.title("LED Meister")
menubar = Menu(self.master)
self.master.config(menu=menubar)
fileMenu = Menu(menubar, tearoff=False)
fileMenu.add_command(label="Save settings", command=savesettings)
fileMenu.add_command(label="Save & exit", command=self.onSaveExit)
fileMenu.add_command(label="Exit", command=self.onExit)
menubar.add_cascade(label="File", menu=fileMenu)
optionsMenu = Menu(menubar, tearoff=False)
optionsMenu.add_command(label="Invert rotation",
command=invertrotation)
menubar.add_cascade(label="Options", menu=optionsMenu)
if active == False:
menubar.entryconfig('Options', state='disabled')
portsMenu = Menu(menubar, tearoff=False)
for p in ports:
port.append(str(p[0]))
portsMenu.add_command(label=p, command=makeFunc(port[t]))
t = t + 1
menubar.add_cascade(label="Ports", menu=portsMenu)
self.columnconfigure(0, pad=3)
self.columnconfigure(1, pad=3)
self.columnconfigure(2, pad=3)
self.columnconfigure(3, pad=3)
self.rowconfigure(0, pad=3)
self.rowconfigure(1, pad=3)
self.rowconfigure(2, pad=3)
self.rowconfigure(3, pad=3)
rbbutton = Button(self, text="Rainbow", command=rainbow)
if active == False:
rbbutton['state'] = 'disabled'
rbbutton.grid(row=1, column=0)
bwbutton = Button(self, text="B&W", command=baw)
if active == False:
bwbutton['state'] = 'disabled'
bwbutton.grid(row=1, column=1)
firebutton = Button(self, text="Fire 1", command=fire1)
if active == False:
firebutton['state'] = 'disabled'
firebutton.grid(row=1, column=2)
fire2button = Button(self, text="Fire 2", command=fire2)
if active == False:
fire2button['state'] = 'disabled'
fire2button.grid(row=1, column=3)
lavabutton = Button(self, text="Lava", command=lava)
if active == False:
lavabutton['state'] = 'disabled'
lavabutton.grid(row=2, column=0)
oceanbutton = Button(self, text="Ocean", command=ocean)
if active == False:
oceanbutton['state'] = 'disabled'
oceanbutton.grid(row=2, column=1)
polbutton = Button(self, text="Police", command=police)
if active == False:
polbutton['state'] = 'disabled'
polbutton.grid(row=2, column=2)
forbutton = Button(self, text="Forest", command=forest)
if active == False:
forbutton['state'] = 'disabled'
forbutton.grid(row=2, column=3)
colbutton = Button(self, text="Party", command=party)
if active == False:
colbutton['state'] = 'disabled'
colbutton.grid(row=3, column=0)
parbutton = Button(self, text="Solid color", command=customColor)
parbutton.grid(row=3, column=1)
offbutton = Button(self, text="Turn off", command=turnoff)
offbutton.grid(row=3, column=3)
brightslider = Scale(self,
from_=0,
to=127,
orient=HORIZONTAL,
label="Brightness",
showvalue=0,
sliderlength=20,
length=230,
width=10)
brightslider.set(bright)
brightslider.grid(row=4, column=0, columnspan=3)
setbrightness = Button(self, text="Set", command=setbright)
setbrightness.grid(row=4, column=3)
speedslider = Scale(self,
from_=25,
to=255,
orient=HORIZONTAL,
label="Speed",
showvalue=0,
sliderlength=20,
length=230,
width=10)
speedslider.set(speed)
speedslider.grid(row=5, column=0, columnspan=3)
setspeedbut = Button(self, text="Set", command=setspeed)
if active == False:
setspeedbut['state'] = 'disabled'
setspeedbut.grid(row=5, column=3)
porttext = Label(self, text=status)
porttext.grid(row=6, column=0, columnspan=4)
self.pack()
class View:
control = ""
interfaces = ""
networks = ""
width = 850
height = 470
interfaces_old = []
networks_old = []
encryption_types = ('ALL', 'WEP', 'WPA')
channels = ('ALL', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11',
'12', '13', '14')
mac_spoofing_status = False
silent_mode_status = False
icon_path = "resources/icon.png"
icon_path_small = "resources/icon_small.png"
def __init__(self, control):
self.control = control
self.splash = Splash()
self.popup_gen = PopUpWindow()
def build_window(self):
"""
Generates the window.
:author: Pablo Sanz Alguacil
"""
self.root = Tk()
self.root.protocol("WM_DELETE_WINDOW", self.notify_kill)
try:
self.root.style = ttk.Style()
self.root.style.theme_use('default')
except:
pass
# get screen width and height
ws = self.root.winfo_screenwidth()
hs = self.root.winfo_screenheight()
# calculate position x, y
x = (ws / 2) - (self.width / 2)
y = (hs / 2) - (self.height / 2)
self.root.geometry('%dx%d+%d+%d' % (self.width, self.height, x, y))
self.root.resizable(width=False, height=False)
self.root.title('WiCC - Wifi Cracking Camp')
icon = Image("photo", file=self.icon_path_small)
self.root.call('wm', 'iconphoto', self.root._w, icon)
# MENU BAR
self.menubar = Menu(self.root)
self.root['menu'] = self.menubar
self.file_menu = Menu(self.menubar)
self.tools_menu = Menu(self.menubar)
self.help_menu = Menu(self.menubar)
self.menubar.add_cascade(menu=self.file_menu, label='File')
self.menubar.add_cascade(menu=self.tools_menu, label='Tools')
self.menubar.add_cascade(menu=self.help_menu, label='Help')
# MENU 1
self.file_menu.add_command(label='Show cracked passwords',
command=self.show_cracked_passwords,
underline=13,
compound=LEFT)
self.file_menu.add_command(label='Temporary files location',
command=self.temporary_files_location,
underline=0,
compound=LEFT)
self.file_menu.add_command(label='Select wordlist',
command=self.select_custom_wordlist,
underline=7,
compound=LEFT)
self.file_menu.add_command(label='Exit',
command=self.notify_kill,
underline=0,
compound=LEFT)
# MENU 2
self.tools_menu.add_command(label='MAC menu',
command=self.mac_tools_window,
underline=0,
compound=LEFT)
self.tools_menu.add_command(label='Generate wordlist',
command=self.generate_wordlists_window,
underline=0,
compound=LEFT)
self.tools_menu.add_command(label='Decrypt capture file',
command=self.decrypt_cap_file,
underline=0,
compound=LEFT)
# MENU 3
self.help_menu.add_command(label='Help',
command=self.open_link,
underline=0,
compound=LEFT)
self.help_menu.add_command(label='About',
command=self.show_about,
underline=0,
compound=LEFT)
# LABEL FRAME - SCAN
self.labelframe_scan = LabelFrame(self.root, text="Scan")
self.labelframe_scan.pack(fill="both", expand="yes")
# LABEL FRAME - FILTERS
self.labelframe_filters = LabelFrame(self.root,
text="Optional Filters")
self.labelframe_filters.pack(fill="both", expand="yes")
# LABEL FRAME - AVAILABLE NETWORKS
self.labelframe_networks = LabelFrame(self.root,
text="Available Networks")
self.labelframe_networks.pack(fill="both", expand="yes")
# LABEL FRAME - SELECT NETWORK NETWORK
self.labelframe_sel_net = LabelFrame(self.root, text="")
self.labelframe_sel_net.pack(fill="both", expand="yes")
self.labelframe_sel_net.grid_columnconfigure(1, weight=1)
# LABEL FRAME - ATTACK OPTIONS
self.labelframe_attack_options = LabelFrame(self.root,
text="Attack Options")
self.labelframe_attack_options.pack(fill="both", expand="yes")
# LABEL FRAME - WEP
self.labelframe_wep = LabelFrame(self.root, text="WEP Attack Options")
# LABEL FRMAE - WPA
self.labelframe_wpa = LabelFrame("", text="WPA Attack Options")
# LABEL - INTERFACES
self.label_interfaces = Label(self.labelframe_scan, text="Interface: ")
self.label_interfaces.grid(column=1, row=0, padx=5)
# COMBO BOX - NETWORK INTERFACES
self.interfaceVar = StringVar()
self.interfaces_combobox = ttk.Combobox(self.labelframe_scan,
textvariable=self.interfaceVar,
state="readonly")
self.interfaces_combobox['values'] = self.interfaces
self.interfaces_combobox.bind("<<ComboboxSelected>>")
self.interfaces_combobox.grid(column=2, row=0)
# FRAME - START/STOP SCAN
self.frame_start_stop = Frame(self.labelframe_scan)
self.frame_start_stop.grid(column=3, row=0, padx=230, pady=5)
# BUTTON - START SCAN
self.button_start_scan = Button(self.frame_start_stop,
text=' Scan networks ',
command=self.start_scan)
self.button_start_scan.grid(column=1, row=0, padx=5)
# BUTTON - STOP SCAN
self.button_stop_scan = Button(self.frame_start_stop,
text=' Stop scanning ',
state=DISABLED,
command=self.stop_scan)
self.button_stop_scan.grid(column=2, row=0, padx=5)
# LABEL - CHANNELS
self.label_channels = Label(self.labelframe_filters,
text="Channel: ",
padx=10,
pady=10)
self.label_channels.grid(column=1, row=0)
# COMBO BOX - CHANNELS
self.channelVar = StringVar()
self.channels_combobox = ttk.Combobox(self.labelframe_filters,
textvariable=self.channelVar,
state="readonly")
self.channels_combobox['values'] = self.channels
self.channels_combobox.bind("<<ComboboxSelected>>")
self.channels_combobox.current(0)
self.channels_combobox.grid(column=2, row=0)
# LABEL - ENCRYPTIONS
self.label_encryptions = Label(self.labelframe_filters,
text="Encryption: ")
self.label_encryptions.grid(column=3, row=0, padx=5)
# COMBO BOX - ENCRYPTOION
self.encryptionVar = StringVar()
self.encryption_combobox = ttk.Combobox(
self.labelframe_filters,
textvariable=self.encryptionVar,
state="readonly")
self.encryption_combobox['values'] = self.encryption_types
self.encryption_combobox.current(0)
self.encryption_combobox.bind("<<ComboboxSelected>>")
self.encryption_combobox.grid(column=4, row=0)
# CHECKBOX - CLIENTS
self.clients_status = BooleanVar()
self.clients_checkbox = Checkbutton(self.labelframe_filters,
text="Only clients",
variable=self.clients_status)
self.clients_checkbox.grid(column=5, row=0, padx=15)
# TREEVIEW - NETWORKS
self.networks_treeview = ttk.Treeview(self.labelframe_networks)
self.networks_treeview["columns"] = ("id", "bssid_col", "channel_col",
"encryption_col", "power_col",
"clients_col")
self.networks_treeview.column("id", width=60)
self.networks_treeview.column("bssid_col", width=150)
self.networks_treeview.column("channel_col", width=60)
self.networks_treeview.column("encryption_col", width=85)
self.networks_treeview.column("power_col", width=70)
self.networks_treeview.column("clients_col", width=60)
self.networks_treeview.heading("id", text="ID")
self.networks_treeview.heading("bssid_col", text="BSSID")
self.networks_treeview.heading("channel_col", text="CH")
self.networks_treeview.heading("encryption_col", text="ENC")
self.networks_treeview.heading("power_col", text="PWR")
self.networks_treeview.heading("clients_col", text="CLNTS")
self.scrollBar = Scrollbar(self.labelframe_networks)
self.scrollBar.pack(side=RIGHT, fill=Y)
self.scrollBar.config(command=self.networks_treeview.yview)
self.networks_treeview.config(yscrollcommand=self.scrollBar.set)
self.networks_treeview.pack(fill=X)
# BUTTON - SELECT NETWORK
self.button_select_network = Button(self.labelframe_sel_net,
text="1 - Select network",
command=self.select_network,
state=DISABLED)
self.button_select_network.grid(column=1,
row=0,
padx=5,
pady=5,
sticky=W + E + N + S)
# CHECKBUTTON - SILENT MODE
self.checkbutton_silent = Checkbutton(self.labelframe_sel_net,
text="Silent Mode",
command=self.silent_mode)
self.checkbutton_silent.grid(column=2, row=0, padx=5, pady=5, sticky=W)
# CHECKBUTTON - SILENT MODE
self.button_select_wordlist = Button(
self.labelframe_sel_net,
text=" Select wordlist",
command=self.select_custom_wordlist)
self.button_select_wordlist.grid(column=3,
row=0,
padx=5,
pady=5,
sticky=W)
# LABEL - NULL LABEL
self.label_info_attack = Label(
self.labelframe_attack_options,
text="Select a network to see the available options")
self.label_info_attack.grid(column=0, row=0, padx=5)
# BUTTON - START ATTACK WEP
self.button_start_attack_wep = Button(self.labelframe_wep,
text="2 - Attack",
command=self.start_attack)
self.button_start_attack_wep.grid(column=0, row=0, padx=5)
# BUTTON - DOS ATTACK WEP
self.button_dos_wep = Button(self.labelframe_wep,
text="DoS Attack",
command=self.dos_attack)
self.button_dos_wep.grid(column=1, row=0, padx=640)
# BUTTON - SCAN WPA
self.button_scan_wpa = Button(self.labelframe_wpa,
text="2 - Capture handshake",
command=self.start_scan_wpa)
self.button_scan_wpa.grid(column=0, row=0, padx=5)
# BUTTON - START ATTACK WPA
self.button_start_attack_wpa = Button(self.labelframe_wpa,
text="3 - Attack",
command=self.start_attack)
self.button_start_attack_wpa.grid(column=1, row=0, padx=5)
# BUTTON - DOS ATTACK WPA
self.button_dos_wpa = Button(self.labelframe_wpa,
text="DoS Attack",
command=self.dos_attack)
self.button_dos_wpa.grid(column=2, row=0, padx=455)
self.root.mainloop()
def select_network(self):
"""
Changes the attack labelframe to WEP or WPA depending on the selected network. Then ends the selected network to
Control.
:author: Pablo Sanz Alguacil
"""
try:
current_item = self.networks_treeview.focus()
network_enc = self.networks_treeview.item(
current_item)['values'][3]
network_id = self.networks_treeview.item(current_item)['values'][0]
if "WEP" in network_enc:
self.labelframe_attack_options.pack_forget()
self.labelframe_wpa.pack_forget()
self.labelframe_wep.pack(fill="both", expand="yes")
elif "WPA" in network_enc:
self.labelframe_attack_options.pack_forget()
self.labelframe_wep.pack_forget()
self.labelframe_wpa.pack(fill="both", expand="yes")
self.send_notify(Operation.SELECT_NETWORK, network_id)
except:
self.send_notify(Operation.SELECT_NETWORK, "")
def start_scan(self):
"""
Sends filters to Control and the sends the selected interface to Control to start scanning.
Activates button dehabilitation.
:author: Pablo Sanz Alguacil
"""
self.set_buttons(False)
self.send_notify(Operation.SCAN_OPTIONS, self.apply_filters())
self.send_notify(Operation.SELECT_INTERFACE, self.interfaceVar.get())
def stop_scan(self):
"""
Sends the stop scannig order to Control.
Deactivates buttons dehabilitation.
:author: Pablo Sanz Alguacil
"""
self.set_buttons(True)
self.send_notify(Operation.STOP_SCAN, "")
def set_buttons(self, status):
"""
Sets all buttons state to "ACTIVE" or "DISABLED".
:param status: boolean
:author: Pablo Sanz Alguacil
"""
if status:
state = ACTIVE
self.button_stop_scan['state'] = DISABLED
self.menubar.entryconfig("File", state="normal")
self.menubar.entryconfig("Tools", state="normal")
self.menubar.entryconfig("Help", state="normal")
else:
state = DISABLED
self.button_stop_scan['state'] = ACTIVE
self.menubar.entryconfig("File", state="disabled")
self.menubar.entryconfig("Tools", state="disabled")
self.menubar.entryconfig("Help", state="disabled")
self.interfaces_combobox['state'] = state
self.encryption_combobox['state'] = state
self.channels_combobox['state'] = state
self.clients_checkbox['state'] = state
self.button_start_scan['state'] = state
self.button_select_network['state'] = state
self.checkbutton_silent['state'] = state
self.button_start_attack_wep['state'] = state
self.button_scan_wpa['state'] = state
self.button_start_attack_wpa['state'] = state
self.checkbutton_silent['state'] = state
self.button_select_wordlist['state'] = state
self.button_dos_wep['state'] = state
self.button_dos_wpa['state'] = state
def start_attack(self):
"""
Sends an order d to Control, to start the attack.
:author: Pablo Sanz Alguacil
"""
self.send_notify(Operation.ATTACK_NETWORK, "")
def notify_kill(self):
"""
Sends and order to kill all processes when X is clicked
:author: Pablo Sanz Alguacil
"""
self.send_notify(Operation.STOP_RUNNING, "")
def reaper_calls(self):
"""
Receives a notification to kill root
:author: Pablo Sanz Alguacil
"""
self.root.destroy()
def select_custom_wordlist(self):
"""
Shows a window to select a custom wordlist to use. Then sends the path to control.
:author: Pablo Sanz Alguacil
"""
select_window = filedialog.askopenfilename(
parent=self.root,
initialdir='/home',
title='Choose wordlist file',
filetypes=[('Text files', '.txt'), ('List files', '.lst'),
("All files", "*.*")])
if select_window:
try:
self.send_notify(Operation.SELECT_CUSTOM_WORDLIST,
select_window)
except:
self.popup_gen.error(
"Open Source File",
"Failed to read file \n'%s'" % select_window)
return
def randomize_mac(self):
"""
Generates a popup window asking for authorisation to change the MAC, then sends the randomize order to Control,
and shows another popup showing the new MAC.
:author: Pablo Sanz Alguacil
"""
if self.interfaceVar.get() != "":
current_mac_alert = self.popup_gen.yesno(
"", "Your current MAC is: " + self.current_mac() +
"\n\nAre you sure you want to change it? ")
if current_mac_alert:
self.send_notify(Operation.RANDOMIZE_MAC,
self.interfaceVar.get())
self.popup_gen.info("",
"Your new MAC is: " + self.current_mac())
else:
self.popup_gen.warning(
"", "No interface selected. Close the window and select one")
def customize_mac(self, new_mac):
"""
Generates a popup window asking for authorisation to change the MAC, then sends the customize order to Control,
and shows another popup showing the new MAC.
:param new_mac: new MAC to be set
:author: Pablo Sanz Alguacil
"""
if self.interfaceVar.get() != "":
current_mac_alert = self.popup_gen.yesno(
"", "Your current MAC is: " + self.current_mac() +
"\n\nAre you sure you want to change it for\n" + new_mac +
" ?")
if current_mac_alert:
self.send_notify(Operation.CUSTOMIZE_MAC,
(self.interfaceVar.get(), new_mac))
self.popup_gen.info("",
"Your new MAC is: " + self.current_mac())
else:
self.popup_gen.warning(
"", "No interface selected. Close the window and select one")
def restore_mac(self):
"""
Generates a popup window asking for authorisation to restore the MAC, then sends the restore order to Control,
and shows another popup showing the new MAC.
:author: Pablo Sanz Alguacil
"""
if self.interfaceVar.get() != "":
current_mac_alert = messagebox.askyesno(
"", "Your current MAC is: " + self.current_mac() +
"\n\nAre you sure you want to restore original?")
if current_mac_alert:
self.send_notify(Operation.RESTORE_MAC,
self.interfaceVar.get())
self.popup_gen.info("",
"Your new MAC is: " + self.current_mac())
else:
self.popup_gen.warning(
"", "No interface selected. Close the window and select one")
def spoofing_mac(self, status):
"""
Sends the order to activate MAC spoofing to Control.
:param status: current status of MAC spoofing
:author: Pablo Sanz Alguacil
"""
if self.interfaceVar.get() != "":
self.send_notify(Operation.SPOOF_MAC, status)
else:
self.popup_gen.warning(
"", "No interface selected. Close the window and select one")
def mac_tools_window(self):
"""
Generates the MAC tools window.
Activates buttons dehabilitation.
:author: Pablo Sanz Alguacil
"""
self.disable_window(True)
ViewMac(self, self.mac_spoofing_status)
def apply_filters(self):
"""
[0]ENCRYPTION (string)
[1]WPS (boolean)
[2]CLIENTS (boolean)
[3]CHANNEL (string)
Sets the filters parameters depending on the options choosed.
:return: array containing filter parameters
:author: Pablo Sanz Alguacil
"""
filters_status = ["ALL", False, False, "ALL"]
if self.encryptionVar.get() != "ALL":
filters_status[0] = self.encryptionVar.get()
if self.clients_status.get():
filters_status[2] = True
if self.channelVar.get() != "ALL":
filters_status[3] = self.channelVar.get()
return filters_status
def get_notify(self, interfaces, networks):
"""
Introduces the interfaces and networks received in their respective structures.
:param interfaces: array containing strings of the interfaces names.
:param networks: array containing the networks and its properties.
:author: Pablo Sanz Alguacil
"""
if interfaces:
self.interfaces_old = interfaces
interfaces_list = []
for item in interfaces:
interfaces_list.append(item[0])
self.interfaces_combobox['values'] = interfaces_list
self.interfaces_combobox.update()
self.networks_old = networks
self.networks_treeview.delete(*self.networks_treeview.get_children())
for item in networks:
self.networks_treeview.insert("",
END,
text=item[13],
values=(item[0], item[1], item[4],
item[6], item[9] + " dbi",
item[16]))
self.networks_treeview.update()
def current_mac(self):
"""
Gets the current MAC from Control.
:return: string containing the MAC address
:author: Pablo Sanz Alguacil
"""
return str(self.control.mac_checker(self.interfaceVar.get()))
def get_notify_childs(self, operation, value):
"""
[0] Custom MAC
[1] Random MAC
[2] Restore MAC
[3] MAC spoofing
[4] Save directory to generated wordlists
[5] Generate wordlist
[6] DoS Attack
Manages the operations received by the child windows (MAC tools, Crunch window)
:param operation: integer. Is the id of the operation.
:param value: value of the operation
:author: Pablo Sanz Alguacil
"""
if operation == 0:
self.customize_mac(value)
elif operation == 1:
self.randomize_mac()
elif operation == 2:
self.restore_mac()
elif operation == 3:
self.mac_spoofing_status = value
self.spoofing_mac(value)
elif operation == 4:
self.send_notify(Operation.PATH_GENERATED_LISTS, value)
elif operation == 5:
self.send_notify(Operation.GENERATE_LIST, value)
elif operation == 6:
self.send_notify(Operation.DOS_ATTACK, value)
def get_spoofing_status(self):
"""
Gets the current spoofing status.
:return: boolean
:author: Pablo Sanz Alguacil
"""
return self.mac_spoofing_status
def send_notify(self, operation, value):
"""
Sends an order to Control
:param operation: Opertaion from Operations class
:param value: value of the operation
:return:
:author: Pablo Sanz Alguacil
"""
self.control.get_notify(operation, value)
return
def disable_window(self, value):
"""
Disables all buttons
:param value: boolean. True for disable, False for enable.
:author: Pablo Sanz Alguacil
"""
if value:
self.set_buttons(False)
self.button_stop_scan['state'] = DISABLED
elif not value:
self.set_buttons(True)
def generate_wordlists_window(self):
"""
Generates the custom wordlists generator window.
:author: Pablo Sanz Alguacil
"""
self.disable_window(True)
GenerateWordlist(self)
def temporary_files_location(self):
"""
Shows a window to select a location to save temporary files. Then sends the path to control.
:author: Pablo Sanz Alguacil
"""
select_window = filedialog.askdirectory(parent=self.root,
initialdir='/home',
title='Choose directory')
if select_window:
try:
self.send_notify(Operation.SELECT_TEMPORARY_FILES_LOCATION,
select_window)
except:
self.popup_gen.error(
"Error", "Failed to set directory \n'%s'" % select_window)
return
def start_scan_wpa(self):
"""
Sends a notification to start a WPA scan.
:author: Pablo Sanz Alguacil
"""
self.send_notify(Operation.START_SCAN_WPA, "")
def silent_mode(self):
"""
Sends an order to control to set or unset the silent mode. Saves the status in a local variable.
:author: Pablo Sanz Alguacil
"""
if self.silent_mode_status:
self.silent_mode_status = False
self.send_notify(Operation.SILENT_SCAN, False)
else:
self.silent_mode_status = True
self.send_notify(Operation.SILENT_SCAN, True)
def get_notify_buttons(self, buttons, state):
"""
Gets a notification to enable or disable buttons from the wep and wpa labelframes.
:param buttons: Array[String] names of the buttons to be dissabled.
:param state: boolean
:author: Pablo Sanz Alguacil
"""
if state:
status = ACTIVE
else:
status = DISABLED
for button in buttons:
if button == "scan_wpa":
self.button_scan_wpa['state'] = status
elif button == "attack_wpa":
self.button_start_attack_wpa['state'] = status
elif button == "attack_wep":
self.button_start_attack_wep['state'] = status
elif button == "select network":
self.button_select_network['state'] = status
def show_about(self):
"""
Creates a new About object
:author: Pablo Sanz Alguacil
"""
About()
def open_link(self):
"""
Opens the URL on a new tab in the default web browser.
:author: Pablo Sanz Alguacil
"""
url = "http://www.github.com/pabloibiza/WiCC"
webbrowser.open_new_tab(url)
def show_cracked_passwords(self):
"""
Sends a notification to Control to open the cracked passwords file.
:author: Pablo Sanz Alguacil
"""
self.send_notify(Operation.OPEN_CRACKED, "")
def dos_attack(self):
"""
Sends an order to control to start a DoS Attack.
:author: Pablo Sanz Alguacil
"""
self.disable_window(True)
DoS(self)
def decrypt_cap_file(self):
"""
Sends a notification and a path to Control to decrypt a .cap file.
:author: Pablo Sanz Alguacil
"""
file_path = filedialog.askopenfilename(parent=self.root,
initialdir='/home',
title='Choose wordlist file',
filetypes=[
('Capture', '.cap'),
('Packet Capture', '.cap'),
("All files", "*.*")
])
self.send_notify(Operation.DECRYPT_FILE, file_path)
command = [
'pyrit', '-r', file_path, 'analyze', '|', 'grep', 'AccessPoint',
'|', 'awk', '\'{$1=\"\";', 'print', '$0}\'', '|', 'sed',
'\"s/[()\']//g;s/.$//\"', '|', 'sort'
]
class TextPreprocesser():
"""
Text Preprocesser class
"""
def __init__(self, master):
self.master = master
self.master.title("Text Preprocesser")
self.master.geometry("250x150")
self.master.resizable(False, False)
self.filename = ""
self.stop_words = set(stopwords.words('english'))
self.word_counter = 0
# menu
self.menu = Menu(self.master)
self.file_menu = Menu(self.menu, tearoff=0)
self.file_menu.add_command(label="Insert a file",
accelerator='Ctrl+O',
command=self.addf)
self.file_menu.add_command(label="Close a file",
accelerator='Ctrl+F5',
state="disable",
command=self.closef)
self.file_menu.add_command(label="Create a report file",
accelerator='Alt+F5',
command=self.filereport)
self.file_menu.add_command(label="Exit",
accelerator='Alt+F4',
command=self.exitmenu)
self.menu.add_cascade(label="File", menu=self.file_menu)
self.edit_menu = Menu(self.menu, tearoff=0)
self.edit_menu.add_command(label="Remove stop words",
accelerator='Alt + R',
command=self.stopw)
self.edit_menu.add_command(label="Remove punctuation",
accelerator='Alt + P',
command=self.rempunf)
self.edit_menu.add_command(label="Words to lower case",
accelerator='Ctrl+L',
command=self.wordlow)
self.menu.add_cascade(label="Edit", menu=self.edit_menu)
self.show_menu = Menu(self.menu, tearoff=0)
self.show_menu.add_command(label="Word counter and distribution",
accelerator='Alt + W',
command=self.wcd)
self.show_menu.add_command(label="Available Stop Words Lan",
accelerator='Ctrl + S',
command=showstopwordlan)
self.menu.add_cascade(label="Show", menu=self.show_menu)
self.about_menu = Menu(self.menu, tearoff=0)
self.about_menu.add_command(label="About",
accelerator='Ctrl+I',
command=aboutmenu)
self.menu.add_cascade(label="About", menu=self.about_menu)
self.help_menu = Menu(self.menu, tearoff=0)
self.help_menu.add_command(label="Help",
accelerator='Ctrl+F1',
command=helpmenu)
self.menu.add_cascade(label="Help", menu=self.help_menu)
#keybinds
self.master.config(menu=self.menu)
self.master.bind('<Control-s>', lambda event: showstopwordlan())
self.master.bind('<Control-o>', lambda event: self.addf())
self.master.bind('<Control-F5>', lambda event: self.closef())
self.master.bind('<Alt-F5>', lambda event: self.filereport())
self.master.bind('<Alt-F4>', lambda event: self.exitmenu())
self.master.bind('<Control-F1>', lambda event: helpmenu())
self.master.bind('<Control-i>', lambda event: aboutmenu())
self.master.bind('<Alt-r>', lambda event: self.stopw())
self.master.bind('<Alt-p>', lambda event: self.rempunf())
self.master.bind('<Alt-w>', lambda event: self.wcd())
self.master.bind('<Control-l>', lambda event: self.wordlow())
#buttons
self.remsstop = Button(self.master,
text="REMOVE STOP WORDS",
command=self.stopw,
state="disable")
self.remsstop.pack()
#REMOVE PUNCTUATION
self.rempun = Button(self.master,
text="REMOVE PUNCTUATION",
command=self.rempunf,
state="disable")
self.rempun.pack()
#WORD COUNTER AND DISTRIBUTION
self.wordcanddist = Button(self.master,
text="WORD COUNTER AND DISTRIBUTION",
command=self.wcd,
state="disable")
self.wordcanddist.pack()
self.wordstolower = Button(self.master,
text="WORDS TO LOWER CASE",
command=self.wordlow,
state="disable")
self.wordstolower.pack()
def filereport(self):
"""
creates a .txt file report of the inserted .txt file
"""
if self.filename == "":
msg.showerror(
"ERROR",
"NO .TXT FILE.\nINSERT A .TXT FILE TO CREATE A REPORT")
else:
report = open("report.txt", 'w')
report.write("The total number of words of the file are:" +
str(self.word_counter))
report.close()
def closef(self):
""" closes file """
if self.filename == "":
msg.showerror("ERROR", "NO .TXT FILE TO CLOSE")
else:
self.filename = ""
self.wordstolower.configure(state="disable")
self.rempun.configure(state="disable")
self.wordcanddist.configure(state="disable")
self.remsstop.configure(state="disable")
self.file_menu.entryconfig("Close a file", state="disable")
self.file_menu.entryconfig("Insert a file", state="active")
msg.showinfo("CLOSE", "FILE SUCCESSFULLY CLOSED")
def wordlow(self):
""" converts to lowercase"""
if not ".txt" in self.filename:
msg.showerror("ERROR", "IMPORT A .TXT FILE")
else:
file1 = open(str(self.filename), 'r')
line = file1.read()
words = line.lower()
self.filenamesave = filedialog.asksaveasfilename(
initialdir="/",
title="Select file",
filetypes=(("txt files", "*.txt"), ("all files", "*.*")))
if ".txt" in self.filenamesave:
for r in words:
file_save(self.filenamesave, r)
msg.showinfo("SUCCESS",
"WORDS CONVERTED TO LOWER CASE SUCCESSFULLY")
else:
msg.showerror("Abort", "Abort")
def wcd(self):
""" prints the number of words and the words distribution"""
if not ".txt" in self.filename:
msg.showerror("ERROR", "IMPORT A .TXT FILE")
else:
file = open(str(self.filename), 'r')
line = file.read()
token = word_tokenize(line)
self.wordcounter = len(token)
fdist = nltk.FreqDist(token)
msg.showinfo(
"WORD COUNTER AND WORD DISTRIBUTION",
"WORDS:" + str(self.wordcounter) + "DISTRIBUTION" +
str(fdist.most_common()))
def stopw(self):
""" removes stop words"""
if not ".txt" in self.filename:
msg.showerror("ERROR", "IMPORT A .TXT FILE")
else:
file1 = open(str(self.filename), 'r')
line = file1.read()
words = line.split()
self.filenamesave = filedialog.asksaveasfilename(
initialdir="/",
title="Select file",
filetypes=(("txt files", "*.txt"), ("all files", "*.*")))
if ".txt" in self.filenamesave:
for r in words:
if not r in self.stop_words:
file_save(self.filenamesave, r)
msg.showinfo("SUCCESS", "STOP WORDS REMOVED SUCCESSFULLY")
else:
msg.showerror("Abort", "Abort")
def rempunf(self):
""" removes every kind of punctuation """
if not ".txt" in self.filename:
msg.showerror("ERROR", "IMPORT A .TXT FILE")
else:
dict.fromkeys(map(ord, '\n ' + string.punctuation))
file = open(str(self.filename), 'r')
line = file.read()
self.filenamesave2 = filedialog.asksaveasfilename(
initialdir="/",
title="Select file",
filetypes=(("txt files", "*.txt"), ("all files", "*.*")))
if ".txt" in self.filenamesave2:
for r in line:
if r not in string.punctuation:
file_save(self.filenamesave2, r)
msg.showinfo("SUCCESS", "PUNCTUATION REMOVED SUCCESSFULLY")
else:
msg.showerror("Abort", "Abort")
def menuchange(self):
""" changes the state of menus """
self.rempun.configure(state="active")
self.wordcanddist.configure(state="active")
self.remsstop.configure(state="active")
self.wordstolower.configure(state="active")
self.file_menu.entryconfig("Insert a file", state="disable")
self.file_menu.entryconfig("Close a file", state="active")
def addf(self):
""" inserts a .txt file and activates the buttons"""
if not self.filename == "":
msg.showerror("ERROR", "FILE IS ALREADY OPEN")
else:
self.filename = filedialog.askopenfilename(
initialdir="/",
title="Select txt file",
filetypes=(("txt files", "*.txt"), ("all files", "*.*")))
if ".txt" in self.filename:
msg.showinfo("SUCCESS", "TXT FILE ADDED SUCCESSFULLY")
self.menuchange()
else:
self.filename == ""
msg.showerror("ERROR", "NO TXT FILE ADDED ")
def exitmenu(self):
""" exit menu function """
if msg.askokcancel("Quit?", "Really quit?"):
self.master.destroy()
class App:
""" Class using Tkinter to display an animation for each different implemented sort algorithm """
def __init__(self):
self.root = Tk()
self.canvas = Canvas(self.root,
width=500,
height=500,
background="white")
self.intial_numbers = App.get_random_list(60)
self.gen_steps: list
self.animation_speed = 5
self.bar_list: list
self.dot_list: list
# Principal barMenu
self.menubar: Menu
self.sorted = False
# Timer
self.time_to_sort = 0.0
self.start_time = 0
self.actual_time = 0
def start(self):
"""Initialize the UI"""
self.canvas.pack()
self.display()
self.menubar = Menu(self.root)
sort_menu = Menu(self.menubar, tearoff=0)
sort_menu.add_command(label="Bubble Sort",
command=lambda: self.sort("bubble"))
sort_menu.add_command(label='"Better" Bubble Sort',
command=lambda: self.sort("o bubble"))
sort_menu.add_command(label="Selection Sort",
command=lambda: self.sort("selection"))
sort_menu.add_command(label="Insertion Sort",
command=lambda: self.sort("insertion"))
sort_menu.add_command(label="Cocktail Sort",
command=lambda: self.sort("cocktail"))
sort_menu.add_command(label="Bogo Sort",
command=lambda: self.sort("bogo"))
sort_menu.add_command(label="Counting Sort",
command=lambda: self.sort("count"))
sort_menu.add_command(label="Bucket Sort",
command=lambda: self.sort("bucket"))
self.menubar.add_cascade(label="Choose Sort", menu=sort_menu)
self.menubar.add_cascade(label="Randomize", command=self.random)
self.menubar.add_cascade(label="Time to sort " +
str(self.time_to_sort) + " s")
self.menubar.add_cascade(label="Exit", command=self.root.quit)
self.root.overrideredirect(0)
self.root.title("Sorting Algorithm Tool")
directory_path = os.path.dirname(os.path.realpath(__file__))
img_path = os.path.join(directory_path, "ico.png")
img = PhotoImage(file=img_path)
self.root.tk.call("wm", "iconphoto", self.root._w, img)
self.root.resizable(width=False, height=False)
self.root.config(menu=self.menubar)
self.root.mainloop()
@classmethod
def get_random_list(cls, size: str) -> list:
"""
Return an array of int fill with random number between 4 and 10000
List type is useful : max value is used to map size of bars to values
"""
return [randint(4, 10000) for _ in range(int(size))]
def sort(self, sort: str):
"""Method use to sort the array with the corresponding sort if it is not sorted yet , and call the animation method after"""
if not self.sorted:
self.start_time = time.time()
if sort == "bubble":
self.gen_steps = bubble_sort(self.intial_numbers)
self.animation_speed = 1
elif sort == "o bubble":
self.gen_steps = optimised_bubble_bort(self.intial_numbers)
self.animation_speed = 1
elif sort == "selection":
self.gen_steps = selection_sort(self.intial_numbers)
self.animation_speed = 5
elif sort == "insertion":
self.gen_steps = insertion_sort(self.intial_numbers)
self.animation_speed = 5
elif sort == "cocktail":
self.gen_steps = cocktail_sort(self.intial_numbers)
self.animation_speed = 1
elif sort == "bogo":
self.gen_steps = bogo_sort(self.intial_numbers)
self.animation_speed = 1
elif sort == "count":
self.gen_steps = counting_sort(self.intial_numbers)
self.animation_speed = 5
elif sort == "bucket":
self.gen_steps = bucket_sort(self.intial_numbers)
self.animation_speed = 5
self.dynamic_display()
self.menubar.entryconfig(2, state="disable")
self.sorted = True
else:
print("Already sorted")
def random(self):
"""Method use to sort the list with one of the sorting algorithm"""
self.sorted = False
self.time_to_sort = 0
self.menubar.entryconfig(2, state="normal")
self.menubar.entryconfig(3,
label="Time to sort " +
str(self.time_to_sort) + " s")
self.intial_numbers = App.get_random_list(60)
self.display()
def display(self):
"""Method call to display the unsorted array"""
self.canvas.delete("all")
self.canvas.create_line(100, 100, 100, 400, fill="red", width=3)
self.canvas.create_line(100, 400, 402, 400, fill="red", width=3)
# Used to map the maximum size of the bar to the maximum value
max_num = max(self.intial_numbers)
self.bar_list = []
self.dot_list = []
for i in range(len(self.intial_numbers)):
# Maping sizes and values
self.bar_list.append(
self.canvas.create_line(
105 + i * 5,
399,
105 + i * 5,
(400 - 300 * (self.intial_numbers[i] / max_num)),
fill="green",
width=2,
))
self.dot_list.append(
self.canvas.create_line(
105 + i * 5,
(400 - 300 * (self.intial_numbers[i] / max_num)) - 2,
105 + i * 5,
(400 - 300 * (self.intial_numbers[i] / max_num)),
fill="red",
width=2,
))
def dynamic_display(self):
"""Method use to display the animation"""
# Index of First and Second Number which will be swaped
try:
initial_state = next(self.gen_steps)
except StopIteration:
self.blue_bar()
self.menubar.entryconfig(2, state="normal")
return
index_fn, index_sn = initial_state.split("-")
self.swap_bars(int(index_fn), int(index_sn))
self.swap_dots(int(index_fn), int(index_sn))
# self.blue_bar(index_fn, index_sn)
self.actual_time = time.time()
self.time_to_sort = round(self.actual_time - self.start_time, 2)
self.menubar.entryconfig(3,
label="Time to sort " +
str(self.time_to_sort) + " s")
time.sleep(0.01)
self.root.after(self.animation_speed, self.dynamic_display)
def swap_bars(self, index_fn: int, index_sn: int):
"""Swap two bars on the canvas"""
first_bar = self.bar_list[index_fn]
second_bar = self.bar_list[index_sn]
x0_first_bar, y0_first_bar, _, y1_first_bar = self.canvas.coords(
first_bar)
x0_second_bar, y0_second_bar, _, y1_second_bar = self.canvas.coords(
second_bar)
self.canvas.coords(first_bar, x0_second_bar, y0_second_bar,
x0_second_bar, y1_first_bar)
self.canvas.coords(second_bar, x0_first_bar, y0_first_bar,
x0_first_bar, y1_second_bar)
self.bar_list[index_fn], self.bar_list[index_sn] = (
self.bar_list[index_sn],
self.bar_list[index_fn],
)
def swap_dots(self, index_fn: int, index_sn: int):
"""Swap two dots on the canvas"""
first_dot = self.dot_list[index_fn]
second_dot = self.dot_list[index_sn]
x0_first_dot, y0_first_dot, _, y1_first_dot = self.canvas.coords(
first_dot)
x0_second_dot, y0_second_dot, _, y1_second_dot = self.canvas.coords(
second_dot)
self.canvas.coords(first_dot, x0_second_dot, y0_first_dot,
x0_second_dot, y1_first_dot)
self.canvas.coords(second_dot, x0_first_dot, y0_second_dot,
x0_first_dot, y1_second_dot)
self.dot_list[index_fn], self.dot_list[index_sn] = (
self.dot_list[index_sn],
self.dot_list[index_fn],
)
def blue_bar(self):
"""If the sort animation end, all the bars become blue"""
for green_bar in self.bar_list:
self.canvas.itemconfig(green_bar, fill="blue")
class GUI:
def __init__(self):
self.root = Tk()
self.root.title("Batch Image Processor")
self.root.geometry("800x600")
self.files_selected = False
self.preview_filename = ""
self.filepane_open = BooleanVar(value=True)
self.filepane = FilePane(self.root, on_selection=[self.set_preview], on_close=[self.on_filepane_close])
self.batch = ImageBatch()
# Create a toplevel menu (from http://effbot.org/tkinterbook/menu.htm)
self.menubar = Menu(self.root)
# Create a pulldown menu, and add it to the menu bar
self.filemenu = Menu(self.menubar, tearoff=0)
self.filemenu.add_command(label="Open File...", command=self.select_files)
self.filemenu.add_command(label="Open Folder...", command=self.select_folders)
self.filemenu.add_command(label="Set save destination", command=self.select_save_dest)
self.filemenu.add_separator()
self.filemenu.add_command(label="Exit", command=self.root.quit)
self.menubar.add_cascade(label="File", menu=self.filemenu)
self.imagemenu = Menu(self.menubar, tearoff=0)
self.imagemenu.add_command(label="Resize", command=self.image_resize)
self.imagemenu.add_command(label="Crop", command=self.image_crop)
self.menubar.add_cascade(label="Image", menu=self.imagemenu)
self.adjustmentsmenu = Menu(self.menubar, tearoff=0)
self.adjustmentsmenu.add_command(label="Color", command=self.adjust_color)
self.adjustmentsmenu.add_command(label="Contrast", command=self.adjust_contrast)
self.adjustmentsmenu.add_command(label="Brightness", command=self.adjust_brightness)
self.adjustmentsmenu.add_command(label="Sharpness", command=self.adjust_sharpness)
self.menubar.add_cascade(label="Adjustments", menu=self.adjustmentsmenu)
self.viewmenu = Menu(self.menubar, tearoff=0)
self.viewmenu.add_checkbutton(label="Files", onvalue=True, offvalue=False, variable=self.filepane_open, command=self.toggle_filepane)
# self.viewmenu.add_command(label="Files", command=self.adjust_color)
self.menubar.add_cascade(label="View", menu=self.viewmenu)
# effectsmenu = Menu(menubar, tearoff=0)
# effectsmenu.add_command(label="Cut", command=hello)
# effectsmenu.add_command(label="Copy", command=hello)
# effectsmenu.add_command(label="Paste", command=hello)
# menubar.add_cascade(label="Effects", menu=effectsmenu)
self.menubar.add_command(label=":", state='disabled')
self.menubar.add_command(label='Run', command=self.batch.process_all)
# Display the menu
self.root.config(menu=self.menubar)
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
self.canvas = Canvas(self.root)
self.canvas.grid(row=0, column=0)
self.image = None
self.imagesprite = self.canvas.create_image(0, 0, image=None, anchor='nw')
self.sbarV = Scrollbar(self.root, orient='vertical')
self.sbarH = Scrollbar(self.root, orient='horizontal')
self.sbarV.config(command=self.canvas.yview)
self.sbarH.config(command=self.canvas.xview)
self.canvas.config(yscrollcommand=self.sbarV.set)
self.canvas.config(xscrollcommand=self.sbarH.set)
self.sbarV.grid(row=0, column=1, sticky="ns")
self.sbarH.grid(row=1, column=0, sticky="ew")
self.disable_editing()
self.root.mainloop()
def toggle_filepane(self):
if self.filepane_open.get():
self.filepane.show()
else:
self.filepane.hide()
def on_filepane_close(self):
self.filepane_open.set(False)
def enable_editing(self):
self.menubar.entryconfig("Image", state="normal")
self.menubar.entryconfig("Adjustments", state="normal")
self.menubar.entryconfig("Run", state="normal")
def disable_editing(self):
self.menubar.entryconfig("Image", state="disabled")
self.menubar.entryconfig("Adjustments", state="disabled")
self.menubar.entryconfig("Run", state="disabled")
def select_files(self):
self.batch.select_files()
if self.batch.filenames:
self.filepane.set_items(self.batch.filenames)
self.update_preview()
self.enable_editing()
else:
self.disable_editing()
def select_folders(self):
self.batch.select_folders()
if self.batch.filenames:
self.filepane.set_items(self.batch.filenames)
self.update_preview()
self.enable_editing()
else:
self.disable_editing()
def select_save_dest(self):
self.batch.select_save_dest()
def set_preview(self, filename):
self.preview_filename = filename
self.update_preview()
def update_preview(self, *args, **kwargs):
self.image = self.batch.get_tk_image(self.preview_filename)
self.canvas.itemconfig(self.imagesprite, image=self.image)
image_size = self.image.width(), self.image.height()
self.canvas.configure(width=image_size[0], height=image_size[1])
self.canvas.configure(scrollregion=self.canvas.bbox("all"))
def setup_dialog(self, dialog, setter):
dialog.on_change += [setter, self.update_preview]
dialog.on_cancel += [self.batch.cancel_modifier, self.update_preview]
dialog.on_confirm += [self.batch.confirm_modifier]
def image_resize(self):
width, height = self.image.width(), self.image.height()
dialog = ResizeImageDialog(self.root, width, height, maintain_aspect_ratio=self.batch.maintain_aspect_ratio, primary_dimension=self.batch.primary_dimension)
self.setup_dialog(dialog, self.batch.set_image_size)
def image_crop(self):
width, height = self.image.width(), self.image.height()
dialog = CropImageDialog(self.root, width, height, maintain_aspect_ratio=self.batch.maintain_aspect_ratio, primary_dimension=self.batch.primary_dimension, anchor=self.batch.anchor)
self.setup_dialog(dialog, self.batch.set_image_crop)
def adjust_color(self):
dialog = SliderDialog(self.root, 'Adjust Color', self.batch.color, 0, 10.0, 1.0, resolution=0.01)
self.setup_dialog(dialog, self.batch.set_color)
def adjust_contrast(self):
dialog = SliderDialog(self.root, 'Adjust Contrast', self.batch.contrast, 0, 10.0, 1.0, resolution=0.01)
self.setup_dialog(dialog, self.batch.set_contrast)
def adjust_brightness(self):
dialog = SliderDialog(self.root, 'Adjust Brightness', self.batch.brightness, 0, 10.0, 1.0, resolution=0.01)
self.setup_dialog(dialog, self.batch.set_brightness)
def adjust_sharpness(self):
dialog = SliderDialog(self.root, 'Adjust Sharpness', self.batch.sharpness, -10.0, 10.0, 1.0, resolution=0.01)
self.setup_dialog(dialog, self.batch.set_sharpness)
class MediaCopierGui(Tk):
def __init__(self):
Tk.__init__(self)
self.protocol('WM_DELETE_WINDOW', self.check_if_process_running_or_not)
self.resizable(False, False)
self.geometry('750x200')
self.title('Media Copier')
self.sourceDir = None
self.destDir = None
self.ext = None
self.__ButtonState = False
self.files = []
self.chunkSize = 1024 * 1000
self.filenameQueue = []
self.makeWidgets()
###################################################################################
##-------------------------------- GUI PART -------------------------------------##
###################################################################################
def makeWidgets(self):
self.makeMenubar()
self.buttonBox()
self.operationBox()
self.scrollFrame()
#self.tableBox1()
def makeMenubar(self):
self.menuBar = Menu(self)
self.config(menu=self.menuBar)
self.mainMenu()
self.helpMenu()
def mainMenu(self):
pulldown = Menu(self.menuBar, tearoff=0)
pulldown.add_command(label='Settings', command=self.settingField)
pulldown.add_command(label='Exit', command=self.quit)
self.menuBar.add_cascade(label='Main', menu=pulldown)
def helpMenu(self):
pulldown = Menu(self.menuBar, tearoff=0)
pulldown.add_command(label='How-to', command=self.howToInfo)
pulldown.add_command(label='About', command=self.aboutinfo)
self.menuBar.add_cascade(label='Help', menu=pulldown)
def enable_menu(self):
self.menuBar.entryconfig('Main', state='normal')
def disable_menu(self):
self.menuBar.entryconfig('Main', state='disabled')
def operationBox(self):
row = Frame(self)
sourceLab = Label(row, text='Source Path', relief='ridge', width=30)
destLab = Label(row, text='Destination Path', relief='ridge', width=30)
oprtnLab = Label(row, text='Operation', relief='ridge', width=40)
row.pack(side='top', expand='yes', fill='both')
sourceLab.pack(side='left')
destLab.pack(side='left')
oprtnLab.pack(side='left')
def tableBox1(self):
while self.filenameQueue:
if self.__ButtonState:
paths = self.filenameQueue[0]
if not os.path.exists(paths[1]):
sourceFilename = os.path.split(paths[0])[1]
destFilename = os.path.split(paths[1])[1]
maximumValue = os.path.getsize(paths[0])
#print(maximumValue)
row = Frame(self.__veriticalScrollFrame.interior)
sourceLab = Label(row, text=r'..\%s\%s' %(self.currentDate, sourceFilename), relief='sunken', width=30)
destLab = Label(row, text=r'..\%s\%s' %(self.currentDate, destFilename), relief='sunken', width=30)
oprtnProgress = Progressbar(row, orient='horizontal', length=250, maximum=maximumValue, mode='determinate', value=0)
row.pack(side='top', expand='yes', fill='both')
sourceLab.pack(side='left', expand='yes', fill='both')
destLab.pack(side='left', expand='yes', fill='both')
oprtnProgress.pack(side='left', expand='yes', fill='both')
"""
updateQueueValue = Queue()
copying_in_thread = Thread(target=self.copyingFiles, args=(maximumValue, paths[0], paths[1], updateQueueValue))
copying_in_thread.start()
while True:
time.sleep(0.25)
if not updateQueueValue.empty():
value = updateQueueValue.get()
print(value)
oprtnProgress['value'] = value
oprtnProgress.update()
else:
print('job done')
break
updateQueueValue.task_done()
copying_in_thread.join()
"""
updateValue = self.chunkSize
with open(paths[0], 'rb') as fileFrom:
with open(paths[1], 'wb') as fileTo:
for _ in range(int(ceil(maximumValue//self.chunkSize)+1)):
bytesForm = fileFrom.read(self.chunkSize)
if bytesForm:
fileTo.write(bytesForm)
oprtnProgress['value'] = updateValue
oprtnProgress.update()
updateValue = updateValue+self.chunkSize
self.update()
self.filenameQueue.remove(paths)
else:
self.filenameQueue.remove(paths)
else:
print('operation Interrupted')
break
else:
self.after(3000, self.tableBox1)
def scrollFrame(self):
self.__veriticalScrollFrame = VerticalScrolledFrame(self)
self.__veriticalScrollFrame.pack(side='left', expand='yes', fill='both')
def buttonBox(self):
def toggleButton():
if self.__b1['text'] == 'Start':
self.disable_menu()
self.__b1.config(text='Stop')
self.__ButtonState = True
self.fileNames_fetch_in_threads()
self.tableBox1()
else:
self.enable_menu()
self.__b1.config(text='Start')
self.__ButtonState = False
self.__b1 = Button(self, text='Start', command=toggleButton)
self.__b1.pack(side='right', expand='yes', anchor='sw', fill='x')
self.__b1.config(fg='red', font=('courier', 9, 'bold italic'), padx=5, state='disabled')
def enable_button(self):
self.__b1.configure(state='normal')
def disable_button(self):
self.__b1.configure(state='disabled')
def settingField(self):
base = Toplevel(self)
base.title('Setting')
base.resizable(False, False)
base.grab_set()
root1 = Frame(base)
root1.pack()
sourceLabel = Label(root1, text='Source Path')
sourceLabel.pack(side='left', padx=21)
self.__sourcevar = StringVar()
sourceEntry = Entry(root1, textvariable=self.__sourcevar)
sourceEntry.pack(side='left')
button1 = Button(root1, text='Browse', command=self.sourceOpenDirectory)
button1.pack(side='left')
sourceEntry.insert('end', self.__sourcevar.get())
root2 = Frame(base)
root2.pack()
destLabel = Label(root2, text='Destination Path')
destLabel.pack(side='left', padx=10)
self.__destvar = StringVar()
destEntry = Entry(root2, textvariable=self.__destvar)
destEntry.pack(side='left')
button2 = Button(root2, text='Browse', command=self.destOpenDirectory)
destEntry.insert('end', self.__destvar.get())
button2.pack(side='left')
root3 = Frame(base)
root3.pack()
extLabel = Label(root3, text='Name of the Extension')
extLabel.pack(side='left')
self.__extvar = StringVar()
extEntry = Entry(root3, textvariable=self.__extvar)
extEntry.pack(side='left')
root4 = Frame(base)
root4.pack(side='bottom')
ApplyButton = Button(root4, text='Apply', command=self.setSettings, padx=8)
ApplyButton.grid(row=0, column=1, padx=8)
OkButton = Button(root4, text='OK', command=base.destroy)
OkButton.grid(row=0, column=0)
def setSettings(self):
validPath = self.are_SettingFields_valid()
if validPath:
self.sourceDir = self.__sourcevar.get()
self.destDir = self.__destvar.get()
self.ext = self.__extvar.get()
self.enable_button()
#print(M.sourceDir, M.destDir, M.ext)
else:
self.disable_button()
showerror('Setting Field Error!', 'Please input valid paths')
def are_SettingFields_valid(self):
paths = False
for i in (self.__sourcevar, self.__destvar):
paths = os.path.exists(i.get())
return paths
def sourceOpenDirectory(self):
sourcePath = askdirectory()
if sourcePath:
self.__sourcevar.set(sourcePath)
def destOpenDirectory(self):
destPath = askdirectory()
if destPath:
self.__destvar.set(destPath)
def howToInfo(self):
showinfo('How-to', 'Goto Main > Setting\n\n1. Select Source Path\n2. Select Destination Path\n3. Give the extension name\n4. Press "Apply" then "OK"')
def aboutinfo(self):
showinfo('About', 'Media Copier\n\nVERSION: 1.0')
def check_if_process_running_or_not(self):
if self.__ButtonState:
showerror('Process is running','To close the application\nPress "STOP" button to stop copy process')
else:
self.quit()
###################################################################################
##------------------------------- LOGIC PART ------------------------------------##
###################################################################################
def filesNamesFetch(self):
self.fetchDate()
currentSourceDateDir = os.path.join(self.sourceDir, self.currentDate)
currentDestDateDir = os.path.join(self.destDir, self.currentDate)
if self.is_Source_Dest_Path_Exist(currentSourceDateDir, currentDestDateDir):
for fileName in glob(r'%s\*.%s' %(currentSourceDateDir, self.ext)):
if not fileName in self.files:
source = fileName
destination = os.path.join(currentDestDateDir, os.path.split(fileName)[1])
if self.is_sourceFile_completely_received(source):
self.filenameQueue.append((source, destination))
self.files.append(fileName)
def fetchDate(self):
dateNow = datetime.now()
self.currentDate = dateNow.strftime('%d%m%y')
def is_Source_Dest_Path_Exist(self, sourcePath, destPath):
if os.path.exists(sourcePath) and (not os.path.exists(destPath)):
os.mkdir(destPath)
return True
elif os.path.exists(sourcePath) and os.path.exists(destPath):
return True
def is_sourceFile_completely_received(self, sourcePath):
try:
sourceFileObj = open(sourcePath, 'rb')
except PermissionError: return False
else:
sourceFileObj.close()
return True
"""
def copyingFiles(self, value, sourceFile, destFile, updateQueueValue):
updateValue = self.chunkSize
with open(sourceFile, 'rb') as fileFrom:
with open(destFile, 'wb') as fileTo:
for _ in range(int(ceil(value//self.chunkSize)+1)):
bytesForm = fileFrom.read(self.chunkSize)
if bytesForm:
fileTo.write(bytesForm)
updateQueueValue.put(updateValue)
updateValue = updateValue+self.chunkSize
"""
###################################################################################
##------------------------------- LINK PART ------------------------------------##
###################################################################################
def fileNames_fetch_in_threads(self):
if self.__ButtonState:
t1 = Thread(target=self.filesNamesFetch)
t1.start()
t1.join()
self.after(30000, self.fileNames_fetch_in_threads)
class Main(Frame):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.root = self.winfo_toplevel()
self.root.option_add("*Font", "serif 10 bold")
self.root.title(" ".join((APPNAME, VERSION, "| Main")))
self.root.resizable(0,0)
self.root.bind('<Key>', self.__keys)
# Menu
menubar = Menu(self.root)
self.windowsmenu = Menu(menubar, tearoff=0)
self.windowsmenu.add_command(label="[ ] Report window", command=self.__toggle_report)
self.windowsmenu.add_command(label="Plot current model", command=self.__plot)
self.windowsmenu.add_separator()
self.windowsmenu.add_command(label="Quit", command=self.destroy)
menubar.add_cascade(label="Windows", menu=self.windowsmenu)
settingsmenu = Menu(menubar, tearoff=0)
settingsmenu.add_command(label="Spectrum range")
settingsmenu.add_command(label="Color scheme")
menubar.add_cascade(label="Settings", menu=settingsmenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="Help", command=self.__help)
helpmenu.add_separator()
helpmenu.add_command(label="About", command=self.__about)
menubar.add_cascade(label="Help", menu=helpmenu)
self.root.config(menu=menubar)
# disabled menu items
settingsmenu.entryconfig(0, state='disabled')
settingsmenu.entryconfig(1, state='disabled')
helpmenu.entryconfig(0, state='disabled')
# Scale
ctrls = Labelframe(self, text='Control', relief='ridge')
self.e = Scale(ctrls, from_=E_MIN, to=E_MAX, label='Links',
bd=1, width=7, length=150, orient='horizontal')
self.d = Scale(ctrls, from_=D_MIN, to=D_MAX, label='Pages',
bd=1, width=7, length=150, orient='horizontal')
self.e.set(E)
self.d.set(D)
self.e.config(command=self.__refresh)
self.d.config(command=self.__refresh)
self.e.pack(side='left')
self.d.pack(side='right')
self.r_win = False
ctrls.pack(side='top', anchor='e', padx=7, pady=5)
# initialize model
self.generate_model()
self.c = GraphViewer(self, D, self.edge_counts, self.pagerank)
self.c.pack()
# open windows
self.__toggle_report()
def generate_model(self):
edges, self.edge_counts = randEdges(self.d.get(), self.e.get())
self.pagerank = pagerank(edges)
def render(self):
self.generate_model()
self.c.render(self.d.get(), self.edge_counts, self.pagerank)
try: self.r.render(self.pagerank, self.edge_counts, self.d.get(), self.e.get())
except: pass
def __refresh(self, value=None):
self.generate_model()
self.render()
def __toggle_report(self):
if self.r_win:
try: self.r.destroy()
except: pass
self.r_win = False
self.windowsmenu.entryconfig(0, label='[ ] Report window')
return
self.r = Report(Toplevel(self))
self.r.pack()
self.r.render(self.pagerank, self.edge_counts, self.d.get(), self.e.get())
self.r_win = True
self.windowsmenu.entryconfig(0, label='[•] Report window ')
def __plot(self):
try: self.plot_root.destroy()
except: pass
self.plot_root = Toplevel(self)
self.plot_root.title(" ".join((APPNAME, VERSION, "| Plot")))
self.plot_root.resizable(0,0)
draw_figure(self.plot_root, self.pagerank)
self.root.after(1, lambda : self.root.focus_force())
def __keys(self, event):
if event.char == 'q':
self.destroy()
elif event.char == 'r':
self.__toggle_report()
elif event.char == 'p':
self.__plot()
elif event.char == 'x':
try: self.plot_root.destroy()
except: pass
elif event.char == 'n':
self.__refresh()
elif event.char == 'j':
self.d.set(self.d.get()-1)
elif event.char == 'J':
self.d.set(self.d.get()-5)
elif event.char == 'k':
self.d.set(self.d.get()+1)
elif event.char == 'K':
self.d.set(self.d.get()+5)
elif event.char == 'h':
self.e.set(self.e.get()-1)
elif event.char == 'H':
self.e.set(self.e.get()-40)
elif event.char == 'l':
self.e.set(self.e.get()+1)
elif event.char == 'L':
self.e.set(self.e.get()+40)
def __help(self):
pass
def __about(self):
try: self.a.destroy()
except: pass
about_text = "{} {}\n\nUW MATH308(Linear Algebra) Winter 2018".format(APPNAME, VERSION)
self.a = Toplevel(self)
self.a.title(" ".join((APPNAME, VERSION, "| About")))
f = Frame(self.a)
l = Label(f, text=about_text)
b = Button(f, text='Close', command=self.a.destroy)
l.pack(padx=5)
b.pack(pady=10)
f.pack(padx=50, pady=20)
def destroy(self):
super().destroy()
self.root.destroy()
exit(1)
class Main(Frame):
def __init__(self, window, *args, **kwargs):
Frame.__init__(self, window, *args, **kwargs)
self.window = window
self.window.title("YouTube Downloader")
self.window.rowconfigure(0, weigh=1)
self.window.columnconfigure(0, weight=1)
self.format_tuple = ()
self.step = 0
self.bytes = 0
self.max_bytes = 0
# Create a Queue
self.guiQueue = queue.Queue()
self.create_widgets()
self.path = os.path.abspath(os.getcwd())
def create_widgets(self):
# Variables
self.url_var = tk.StringVar()
# self.url_var.trace_add('write', self.populate_format)
self.save_to_var = tk.StringVar()
self.format_var = tk.StringVar()
self.format_var.trace_add('write', self.check_audio)
self.includes_var = tk.StringVar()
self.percent_var = tk.StringVar()
self.bar_var = tk.IntVar()
self.convert_var = tk.StringVar()
# Create popup menu for Copy/Paste
self.m = Menu(self.window, tearoff=0)
self.m.add_command(label="Cut")
self.m.add_command(label="Copy")
self.m.add_command(label="Paste")
# Main frame
self.main_frame = tk.Frame(self.window)
self.main_frame.grid(column=0, row=0, sticky='wne', padx=10, pady=10)
self.main_frame.rowconfigure(2, weight=1)
self.main_frame.columnconfigure(0, weight=1)
self.main_frame.columnconfigure(1, weight=1)
self.url_frame = ttk.Frame(self.main_frame)
self.url_frame.grid(column=0, row=0, columnspan=2, sticky='enw')
self.url_frame.columnconfigure(1, weight=1)
self.url_label = ttk.Label(self.url_frame, text="URL")
self.url_label.grid(column=0, row=0, sticky='w')
self.url_entry = ttk.Entry(self.url_frame, textvariable=self.url_var)
self.url_entry.grid(column=1, row=0, sticky='ew')
self.save_to_button = ttk.Button(self.url_frame,
text="Save To",
command=self.save_to)
self.save_to_button.grid(column=0, row=1, sticky='w')
self.save_to_entry = ttk.Entry(self.url_frame,
textvariable=self.save_to_var)
self.save_to_entry.grid(column=1, row=1, sticky='ew')
self.download_frame = tk.Frame(self.main_frame)
self.download_frame.columnconfigure(2, weight=1)
self.download_frame.columnconfigure(3, weight=1)
# self.download_frame.columnconfigure(1, weight=1)
self.download_frame.grid(column=0,
row=1,
columnspan=2,
pady=5,
sticky='ew')
self.load_url = ttk.Button(self.download_frame,
text="Load URL",
command=self.populate_format)
self.load_url.grid(column=0, row=0, ipady=10)
self.format_combo = ttk.Combobox(self.download_frame,
textvariable=self.format_var)
self.format_combo.grid(column=1, row=0, padx=10)
self.includes_audio = ttk.Label(self.download_frame,
textvariable=self.includes_var,
width=20)
self.includes_audio.grid(column=2, row=0, padx=10)
self.download_button = ttk.Button(self.download_frame,
text="Download Video",
command=self.download_video)
self.download_button.grid(column=3,
row=0,
ipadx=30,
ipady=10,
sticky='e')
self.download_label = ttk.Label(self.download_frame,
textvariable=self.percent_var)
self.download_label.grid(column=0, row=1, sticky='ew', columnspan=4)
self.download_bar = ttk.Progressbar(self.download_frame,
orient=tk.HORIZONTAL,
mode='determinate',
variable=self.bar_var)
self.download_bar.grid(column=0,
row=2,
columnspan=4,
sticky='ew',
pady=10)
# create a Treeview
self.tree = ttk.Treeview(self.main_frame,
show='headings',
columns=('Name', 'Format', 'Size',
'Resolution'))
self.tree.grid(column=0, row=2, columnspan=2, sticky='wne')
self.tree.bind('<<TreeviewSelect>>', self.file_to_convert)
self.tree.column('Name', width=250, anchor='center')
self.tree.heading('Name', text='Name')
self.tree.column('Format', width=30, anchor='center')
self.tree.heading('Format', text='Format')
self.tree.column('Size', width=70, anchor='center')
self.tree.heading('Size', text='Size')
self.tree.column('Resolution', width=70, anchor='center')
self.tree.heading('Resolution', text='Resolution')
self.check_platform()
self.convert_frame = ttk.Frame(self.main_frame)
self.convert_frame.grid(column=0, row=3, columnspan=2, sticky='ew')
# self.convert_frame.columnconfigure(0, weight=1)
self.convert_frame.columnconfigure(2, weight=1)
# self.convert_frame.columnconfigure(2, weight=1)
# self.convert_frame.columnconfigure(2, weight=1)
self.file_label = ttk.Label(self.convert_frame, text="File name")
self.file_label.grid(column=0, row=0)
self.convert_entry = ttk.Entry(self.convert_frame,
textvariable=self.convert_var)
self.convert_entry.grid(column=1, row=0, sticky='ew')
self.convert_progress = ttk.Progressbar(self.convert_frame,
orient=tk.HORIZONTAL,
mode='indeterminate')
self.convert_progress.grid(column=2, row=0, ipadx=10, sticky='ew')
self.convert_button = ttk.Button(self.convert_frame,
text="Convert Audio",
command=self.convert_video)
self.convert_button.grid(column=3,
row=0,
ipadx=30,
ipady=10,
sticky='e')
def save_to(self):
file_path = filedialog.askdirectory()
self.save_to_var.set(file_path)
self.path = self.save_to_var.get()
def popup(self, event):
try:
self.m.entryconfig(
"Cut", command=lambda: event.widget.event_generate("<<Cut>>"))
self.m.entryconfig(
"Copy",
command=lambda: event.widget.event_generate("<<Copy>>"))
self.m.entryconfig(
"Paste",
command=lambda: event.widget.event_generate("<<Paste>>"))
self.m.tk.call("tk_popup", self.m, event.x_root, event.y_root)
finally:
self.m.grab_release()
def check_platform(self):
plt = platform.system()
if plt == "Windows":
print("Your system is Windows")
self.url_entry.bind("<Button-3>", self.popup)
self.save_to_entry.bind("<Button-3>", self.popup)
elif plt == "Linux":
print("Your system is Linux")
self.url_entry.bind("<Button-3>", self.popup)
self.save_to_entry.bind("<Button-3>", self.popup)
elif plt == "Darwin":
print("Your system is MacOS")
self.url_entry.bind("<Button-2>", self.popup)
self.save_to_entry.bind("<Button-2>", self.popup)
else:
print("Unidentified system")
mBox.showinfo("Copy/Paste functionality not working.")
def file_to_convert(self, *args):
# Reset the convert progressbar if used before
self.convert_progress.stop()
item = self.tree.focus()
item = self.tree.item(item)
self.video_file = item['text']
title_file = item['values'][0]
self.convert_var.set(title_file)
def convert_video(self, *args):
if len(self.convert_var.get()) > 0:
try:
from pydub import AudioSegment
print("Alabama", self.video_file)
if os.path.isfile(self.video_file):
self.convert_progress.start()
self.convert_progress.step(10)
self.convert_progress.update_idletasks()
audio = AudioSegment.from_file(self.video_file)
new_file = self.video_file.replace("mp4", "mp3")
audio.export(new_file, format="mp3", codec="libmp3lame")
# self.convert_progress.stop()
# mBox.showinfo("Convert to MP3", "The video has been converted from MP4 to MP3.")
else:
mBox.showerror(
"Convert to MP3",
"The file to convert doesn't exists!\nPlease check the folder for the actual file!"
)
except:
mBox.showerror("Convert to MP3",
"The conversion to MP3 failed!")
else:
mBox.showwarning(
"Convert to MP3",
"No file selected from the list to be converted!")
def check_audio(self, *args):
""" Check is current stream has audio"""
if self.yt.streams[self.format_combo.current()].includes_audio_track:
self.includes_var.set("Video includes audio? Yes")
else:
self.includes_var.set("Video includes audio? No")
def download_video(self):
if len(self.url_entry.get()) > 0:
self.stream = self.yt.streams[self.format_combo.current()]
# Set progress bar's maximum to video size
self.max_bytes = self.stream.filesize
self.download_bar['maximum'] = 100
self.download_bar['value'] = self.step
self.t1 = threading.Thread(target=self.fill_bar, args=[])
self.t1.start()
else:
mBox.showwarning(
"URL Error",
"You have not entered an Url.\nPlease enter a valid YouTuber Url to download a video."
)
def populate_format(self, *args):
""" Get the streams from URL, filter only the mp4 streams, extract the resolution and fps.
Populate the combo box with the extracted values. """
# TODO extract everything in a different thread
# Reset the convert progressbar if used before
self.convert_progress.stop()
self.format_combo['values'] = ()
try:
self.yt = YouTube(self.url_entry.get(),
on_progress_callback=self.progress_bar,
on_complete_callback=self.insert_tree)
for stream in self.yt.streams.filter(subtype="mp4"):
if stream.includes_video_track:
self.format_tuple += (str(stream.mime_type) + " " +
str(stream.resolution) + " " +
str(stream.fps) + "fps", )
except exceptions.VideoUnavailable as videoUnavailable:
mBox.showerror(
"Error", "Something wrong happened!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " +
str(videoUnavailable.__doc__))
except exceptions.RegexMatchError as regexError:
mBox.showerror(
"Error", "Something wrong happened!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " +
str(regexError.__doc__))
except exceptions.HTMLParseError as htmlParseError:
mBox.showerror(
"Error", "Something wrong happened!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " +
str(htmlParseError.__doc__))
except exceptions.ExtractError as extractError:
mBox.showerror(
"Error", "Something wrong happened!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " +
str(extractError.__doc__))
except exceptions.PytubeError as pytubeError:
mBox.showerror(
"Error", "Something wrong happened!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " +
str(pytubeError.__doc__))
except KeyError as io:
mBox.showerror(
"Error", "Something wrong happened!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " + str(io.__doc__) +
" " + str(io))
except:
mBox.showerror("Error", "Something wrong happened!")
if len(self.format_tuple) > 0:
self.format_combo['values'] = self.format_tuple
self.format_combo.current(0)
self.check_audio()
def progress_bar(self, chunk, file_handle, bytes_remaining):
remaining = (100 * bytes_remaining) / self.max_bytes
self.step = 100 - int(remaining)
self.guiQueue.put(self.step)
self.window.after(1000, self.listen_result)
def fill_bar(self):
if len(self.save_to_var.get()) > 0:
self.path = self.save_to_var.get()
if os.path.isfile(self.path + "/" + str(self.format_combo.current()) +
"_" + self.stream.default_filename):
mBox.showerror("Download error",
"This file already exists!\nPlease check again!")
elif not os.path.isdir(self.path):
mBox.showerror(
"Download error",
"The selected path does not exists!\nPlease check again!")
else:
self.stream.download(
output_path=self.path,
filename_prefix=str(self.format_combo.current()) + "_")
def listen_result(self):
try:
self.step = self.guiQueue.get_nowait()
self.bar_var.set(self.step)
self.percent_var.set("Downloading... " + str(self.step) + "%")
self.window.after(1000, self.listen_result)
except queue.Empty:
# self.window.after(100, self.listen_result)
pass
def insert_tree(self, *args):
""" Insert details of downloaded video into the tree. """
self.percent_var.set("Downloading... " + str(self.step) +
"% Completed!")
iid = self.path + "/" + str(
self.format_combo.current()) + "_" + self.stream.default_filename
name = str(
self.format_combo.current()) + "_" + self.stream.default_filename
video_format = "mp4"
size = str(round(self.stream.filesize * 0.000001, 1)) + "MB"
resolution = self.set_resolution()
try:
self.tree.insert('',
'end',
iid=iid,
text=iid,
values=(name, video_format, size, resolution))
except TclError as err:
mBox.showerror(
"Download error",
"Error after download!\nError on line {}".format(
sys.exc_info()[-1].tb_lineno) + ". " + str(err))
def set_resolution(self):
""" Label the resolution of the video """
if self.stream.resolution == "2160p":
return "3840x2160"
elif self.stream.resolution == "1440p":
return "2560x1440"
elif self.stream.resolution == "1080p":
return "1920x1080"
elif self.stream.resolution == "720p":
return "1280x720"
elif self.stream.resolution == "480p":
return "854x480"
elif self.stream.resolution == "360p":
return "640x360"
elif self.stream.resolution == "240p":
return "426x240"
elif self.stream.resolution == "144p":
return "256x144"
else:
return "No resolution detected"
class CimApp(Frame):
def __init__(self):
Frame.__init__(self)
self.file = None;
self.master.title("Tiborcim")
self.master.iconphoto(True, PhotoImage(file=ICON_PNG))
self.files = []
self.current_tab = StringVar()
self.pack(expand=1, fill="both")
self.master.minsize(300,300)
self.master.geometry("500x500")
self.menubar = Menu(self.master)
self.fileMenu = Menu(self.master, tearoff=0)
self.fileMenu.add_command(label="New", command=self.new_file,
underline=0, accelerator="Ctrl+N")
self.fileMenu.add_command(label="Open...", command=self.load_file,
underline=0, accelerator="Ctrl+O")
self.fileMenu.add_command(label="Save", command=self.file_save,
underline=0, accelerator="Ctrl+S")
self.fileMenu.add_command(label="Save As...", command=self.file_save_as,
underline=5, accelerator="Ctrl+Alt+S")
self.fileMenu.add_command(label="Close", command=self.close_file,
underline=0, accelerator="Ctrl+W")
self.fileMenu.add_separator()
self.fileMenu.add_command(label="Exit", command=self.file_quit, underline=1)
self.menubar.add_cascade(label="File", menu=self.fileMenu, underline=0)
self.edit_program = Menu(self.master, tearoff=0)
self.edit_program.add_command(label="Undo", command=self.edit_undo,
underline=0, accelerator="Ctrl+Z")
self.edit_program.add_command(label="Redo", command=self.edit_redo,
underline=0, accelerator="Ctrl+Y")
self.edit_program.add_separator()
self.edit_program.add_command(label="Cut",
command=self.edit_cut,
underline=2,
accelerator="Ctrl+X")
self.edit_program.add_command(label="Copy",
command=self.edit_copy,
underline=0,
accelerator="Ctrl+C")
self.edit_program.add_command(label="Paste",
command=self.edit_paste,
underline=0,
accelerator="Ctrl+V")
self.menubar.add_cascade(label="Edit", menu=self.edit_program, underline=0)
self.menu_program = Menu(self.master, tearoff=0)
self.menu_program.add_command(label="Convert",
command=self.convert_file,
underline=0,
accelerator="Ctrl+T")
self.menu_program.add_command(label="Flash",
command=self.flash_file,
underline=0,
accelerator="Ctrl+B")
self.menu_program.add_separator()
self.menubar.add_cascade(label="Program", menu=self.menu_program, underline=0)
self.menu_view = Menu(self.master,
tearoff=0)
self.viewmode = StringVar()
self.viewmode.set("tiborcim")
self.menu_view.add_radiobutton(label="Tiborcim",
command=self.view_tiborcim,
variable=self.viewmode,
value="tiborcim",
underline=0)
self.menu_view.add_radiobutton(label="Python",
command=self.view_python,
variable=self.viewmode,
value="python",
underline=0)
self.menubar.add_cascade(label="View",
menu=self.menu_view,
underline=0)
self.menu_help = Menu(self.master,
tearoff=0)
self.menu_samples = Menu(self.master, tearoff=0)
samples = tiborcim.resources.samples_list()
def add_sample (sample):
self.menu_samples.add_command(label=sample,
command=lambda: self.help_sample(sample))
for sample in samples:
add_sample(sample)
self.menu_help.add_cascade(label="Samples",
menu=self.menu_samples,
underline=0)
self.menu_help.add_separator()
self.menu_help.add_command(label="README",
command=self.help_readme,
underline=0)
self.menu_help.add_separator()
self.menu_help.add_command(label="About",
command=self.help_about,
underline=0)
self.menubar.add_cascade(label="Help",
menu=self.menu_help,
underline=0)
self.master.config(width=450,
height=400,
menu=self.menubar)
self.bind_all("<Control-o>", self.load_file)
self.bind_all("<Control-s>", self.file_save)
self.bind_all("<Control-Alt-s>", self.file_save_as)
self.bind_all("<Control-t>", self.convert_file)
self.bind_all("<Control-b>", self.flash_file)
self.bind_all("<Control-w>", self.close_file)
self.master.protocol("WM_DELETE_WINDOW", self.file_quit)
self.file_tabs = Notebook(self)
self.file_tabs.bind_all("<<NotebookTabChanged>>", self.file_changed)
self.file_tabs.pack(expand=1, fill="both")
def file_changed(self, event):
if len(self.file_tabs.tabs()) <= 0:
self.add_file()
return
title = str(event.widget.tab(event.widget.index("current"),"text")).upper().strip()
self.menu_program.delete(3, END)
for tab in self.file_tabs.tabs():
tabtext = self.file_tabs.tab(self.file_tabs.index(tab),"text")
if tabtext.upper().strip() == title:
self.current_tab.set(tab)
self.menu_program.add_radiobutton(label=tabtext, command=self.program_switch,
underline=1, value=tab, variable=self.current_tab)
if title != "PYTHON" or title != "TIBORCIM":
if self.current_file().filename is not None:
self.master.title(self.current_file().get_file() + " - Tiborcim")
else:
self.master.title("Tiborcim")
if str(self.current_file().tab(self.current_file().index("current"),"text")).upper().strip() == "TIBORCIM":
self.menubar.entryconfig("Edit", state=NORMAL)
else:
self.menubar.entryconfig("Edit", state=DISABLED)
self.viewmode.set(self.current_file().viewmode)
if title == "PYTHON":
self.menubar.entryconfig("Edit", state=DISABLED)
self.current_file().viewmode = "python";
self.viewmode.set("python");
if title == "TIBORCIM":
self.menubar.entryconfig("Edit", state=NORMAL)
self.current_file().viewmode = "tiborcim";
self.viewmode.set("tiborcim");
def add_file(self, file=None):
filepage = CimFilePage(self.file_tabs)
if file is None:
self.file_tabs.add(filepage, text="Unsaved Program")
else:
filepage.load_file(file)
self.file_tabs.add(filepage, text=filepage.get_file())
self.files.append(filepage)
self.file_tabs.select(filepage)
def view_tiborcim(self, event=None):
self.current_file().view_tiborcim()
def view_python(self, event=None):
self.current_file().view_python()
def program_switch(self):
self.file_tabs.select(self.current_tab.get())
def new_file(self, event=None):
self.add_file()
def load_file(self, event=None):
fname = askopenfilename(filetypes=(("Tiborcim", "*.tibas"),("All files", "*.*") ), parent=self.master)
if fname:
self.add_file(fname)
def file_save(self, event=None):
self.current_file().save_file()
self.file_tabs.tab(self.current_file(), text=self.current_file().get_file())
def file_save_as(self, event=None):
self.current_file().save_file_as()
self.file_tabs.tab(self.current_file(), text=self.current_file().get_file())
def convert_file(self, event=None):
self.current_file().convert_file()
def current_file(self, event=None):
return self.files[int(self.file_tabs.index(self.file_tabs.select()))]
def flash_file(self, event=None):
from tiborcim.tibc import compiler as tibc
from tiborcim.tibc import flash
from tiborcim.tibc import TibcStatus as status
com = tibc(self.current_file().text_tiborcim.get("1.0", "end"))
res = flash(''.join(com.output))
if res is status.SUCCESS:
showinfo(title='Success', message='File Flashed', parent=self.master)
else:
showerror(title='Failure', message='An Error Occured. Code: %s' % res, parent=self.master)
def close_file(self, event=None):
logging.debug("Close File")
file = self.current_file()
if file.close():
self.file_tabs.forget(file)
self.files.remove(file)
def edit_cut(self, event=None):
self.current_file().text_tiborcim.event_generate('<Control-x>')
def edit_copy(self, event=None):
self.current_file().text_tiborcim.event_generate('<Control-c>')
def edit_paste(self, event=None):
self.current_file().text_tiborcim.event_generate('<Control-v>')
def edit_redo(self, event=None):
self.current_file().text_tiborcim.edit_redo()
def edit_undo(self, event=None):
self.current_file().text_tiborcim.edit_undo()
def help_about(self, event=None):
CimAbout.show(self)
def help_readme(self, event=None):
CimReadme.show(self)
def help_sample(self, sam):
print(sam)
filepage = CimFilePage(self.file_tabs)
filepage.load_file(tiborcim.resources.sample_path(sam))
filepage.filename = None
self.file_tabs.add(filepage, text="Unsaved Program")
self.files.append(filepage)
self.file_tabs.select(filepage)
def file_quit(self, event=None):
for ndx, member in enumerate(self.files):
logging.debug(self.files[ndx].saved)
if not self.files[ndx].close():
return
self.quit()
