def make_window():
"""
Creates the main window
:return: The main window object
:rtype: (Window)
"""
theme = get_theme()
if not theme:
theme = sg.OFFICIAL_PYSIMPLEGUI_THEME
sg.theme(theme)
# First the window layout...2 columns
find_tooltip = "Find in file\nEnter a string in box to search for string inside of the files.\nFile list will update with list of files string found inside."
filter_tooltip = "Filter files\nEnter a string in box to narrow down the list of files.\nFile list will update with list of files with string in filename."
find_re_tooltip = "Find in file using Regular Expression\nEnter a string in box to search for string inside of the files.\nSearch is performed after clicking the FindRE button."
left_col = sg.Col([
[sg.Listbox(values=get_file_list(), select_mode=sg.SELECT_MODE_EXTENDED, size=(50, 20), key='-DEMO LIST-')],
[sg.Text('Filter:', tooltip=filter_tooltip), sg.Input(size=(25, 1), enable_events=True, key='-FILTER-', tooltip=filter_tooltip),
sg.T(size=(15,1), k='-FILTER NUMBER-')],
[sg.Button('Run'), sg.B('Edit'), sg.B('Clear'), sg.B('Open Folder')],
[sg.Text('Find:', tooltip=find_tooltip), sg.Input(size=(25, 1), enable_events=True, key='-FIND-', tooltip=find_tooltip),
sg.T(size=(15,1), k='-FIND NUMBER-')],
], element_justification='l')
lef_col_find_re = sg.pin(sg.Col([
[sg.Text('Find:', tooltip=find_re_tooltip), sg.Input(size=(25, 1),key='-FIND RE-', tooltip=find_re_tooltip),sg.B('Find RE')]], k='-RE COL-'))
right_col = [
[sg.Multiline(size=(70, 21), write_only=True, key=ML_KEY, reroute_stdout=True, echo_stdout_stderr=True)],
[sg.Button('Edit Me (this program)'), sg.B('Settings'), sg.Button('Exit')],
[sg.T('PySimpleGUI ver ' + sg.version.split(' ')[0] + ' tkinter ver ' + sg.tclversion_detailed, font='Default 8', pad=(0,0))],
]
options_at_bottom = sg.pin(sg.Column([[sg.CB('Verbose', enable_events=True, k='-VERBOSE-'),
sg.CB('Show only first match in file', default=True, enable_events=True, k='-FIRST MATCH ONLY-'),
sg.CB('Find ignore case', default=True, enable_events=True, k='-IGNORE CASE-')]],
pad=(0,0), k='-OPTIONS BOTTOM-'))
choose_folder_at_top = sg.pin(sg.Column([[sg.T('Click settings to set top of your tree or choose a previously chosen folder'),
sg.Combo(sorted(sg.user_settings_get_entry('-folder names-', [])), default_value=sg.user_settings_get_entry('-demos folder-', ''), size=(50, 1), key='-FOLDERNAME-', enable_events=True, readonly=True)]], pad=(0,0), k='-FOLDER CHOOSE-'))
# ----- Full layout -----
layout = [[sg.Text('PySimpleGUI Demo Program & Project Browser', font='Any 20')],
[choose_folder_at_top],
sg.vtop([sg.Column([[left_col],[ lef_col_find_re]], element_justification='l'), sg.Col(right_col, element_justification='c') ]),
[options_at_bottom]
]
# --------------------------------- Create Window ---------------------------------
window = sg.Window('PSG Demo & Project Browser', layout, finalize=True, icon=icon)
if not advanced_mode():
window['-FOLDER CHOOSE-'].update(visible=False)
window['-RE COL-'].update(visible=False)
window['-OPTIONS BOTTOM-'].update(visible=False)
sg.cprint_set_output_destination(window, ML_KEY)
return window
def make_window():
"""
Creates a new window. The default values for some elements are pulled directly from the
"User Settings" without the use of temp variables.
Some get_entry calls don't have a default value, such as theme, because there was an initial call
that would have set the default value if the setting wasn't present. Could still put the default
value if you wanted but it would be 2 places to change if you wanted a different default value.
Use of a lookup table to map between element keys and user settings could be aded. This demo
is intentionally done without one to show how to use the settings APIs in the most basic,
straightforward way.
If your application allows changing the theme, then a make_window function is good to have
so that you can close and re-create a window easily.
:return: (sg.Window) The window that was created
"""
sg.theme(sg.user_settings_get_entry('theme', 'DarkBlue2')) # set the theme
layout = [[sg.Text('Settings Window')],
[sg.Input(sg.user_settings_get_entry('input', ''), k='-IN-')],
[sg.Listbox(sg.theme_list(), default_values=[sg.user_settings_get_entry('theme')], size=(15, 10), k='-LISTBOX-')],
[sg.CB('Option 1', sg.user_settings_get_entry('option1', True), k='-CB1-')],
[sg.CB('Option 2', sg.user_settings_get_entry('option2', False), k='-CB2-')],
[sg.T('Settings file = ' + sg.user_settings_filename())],
[sg.Button('Save'), sg.Button('Exit without saving', k='Exit')]]
return sg.Window('A Settings Window', layout)
def _refocus_window(self):
sg.theme('Light Blue 2') # Add a touch of color
# All the stuff inside your window.
col = [[sg.Text('Object Motion ')],
[sg.Text('Nearest Object: '), sg.InputText()],
[sg.Text('Farthest Object: '), sg.InputText()],
[sg.Text('Sensitivity: ')],
[sg.CB('Highest'), sg.CB('High'), sg.CB('Normal'), sg.CB('Low'), sg.CB('Lowest')],
[sg.Button('Compute'), sg.Button('Save')]]
layout = [[sg.Text(' Refocusing ')],
[sg.Image(self.output_temp, key='image')],
[sg.Slider(range=(self.refocus.motion_min, self.refocus.motion_max), resolution=self.slider_resolution, default_value=self.refocus.motion, orientation='v', size=(8, 20), key='slider'), sg.Column(col)]]
# Create the Window
window = sg.Window('Refocus', layout)
# Event Loop to process "events" and get the "values" of the inputs
while True:
event, values = window.read()
if event == None: # if user closes window or clicks cancel
break
elif event == 'Compute':
self._update_refocus_state(values)
window.close()
self._refocus_window()
elif event == 'Save':
dst = sg.popup_get_file("Save output image to disk", title='Save Image',
save_as=True, default_extension=".png",
file_types=(("IMAGES", ".png"),("IMAGES", ".jpg")))
b, g, r = cv.split(self.refocus.output_img*255)
img = Image.fromarray(cv.merge((r, g,b)).astype(np.uint8))
img.save(dst)
window.close()
def generateFlags(self):
"""Generates checkboxes"""
# makes checkboxes: debug, newKW, newSubcat --> used to reveal parts of the window
debug = sg.CB("Debug Mode", default=False, key='-DEBUG-')
onceoff = sg.CB("Once-Off", default=False, key='-ONCEOFF FLAG-')
newKW = sg.CB("New Keyword", default=False, key='-NEW KW FLAG-')
newSubcat = sg.CB("New Subcat",
default=False,
key='-NEW SUBCAT FLAG-',
disabled=True)
return [debug, onceoff, newKW, newSubcat]
def generateFlags(self) -> list:
# makes checkboxes: newKW, newSubcat --> used to reveal parts of the window
onceoff = sg.CB("Once-Off",
default=False,
key=Keys.flag_onceoff,
enable_events=True)
newKW = sg.CB("New Keyword",
default=False,
key=Keys.flag_new_kw,
enable_events=True)
newSubcat = sg.CB("New Subcat",
default=False,
key=Keys.flag_new_subcat,
enable_events=True)
return [onceoff, newKW, newSubcat]
def create_datapack_layout():
"""Create layout for the datapack frame.
Groups all the available datapacks in two columns. Each datapack can
be selected with a Checkbox, which has a default state equal to the
datapack's 'default_enabled' field.
"""
logging.debug("Creating datapack layout")
grouped_packs = [
datapacks[i:i + 2] for i in range(0, len(datapacks), 2)
]
logging.debug(f"Found {len(grouped_packs)} pairs of datapacks")
c1_layout, c2_layout = sg.Sizer(20, 1), sg.Sizer(20, 1)
for d_pair in grouped_packs:
for d, c in zip(d_pair, [c1_layout, c2_layout]):
c.add_row(
sg.CB(d.name,
d.default_enabled, (15, 1),
tooltip=f"{d.name}\n{d.description}"))
return [[c1_layout, c2_layout],
[
sg.T("_" * 35, (41, 0),
justification="center",
pad=(2, 0))
],
[
sg.T("Drop your datapacks in 'assets/datapacks'",
(41, 0),
justification="center",
pad=(2, 0))
]]
def get_layout():
automatic_installation = registry.get_value(
settings.AUTO_INSTALLATIONS_REGISTRY)
update_frame = [
[sg.Button("Query server for update", key="-QUERY_SERVER-")],
[
sg.CB("Automatically update on next launch",
key="-AUTO-",
enable_events=True,
default=automatic_installation)
],
]
installed_version = updater.Version.get_installed_version()
update_version = updater.Version.get_current_version()
layout = [[
sg.Button("Launch", key="-LAUNCH-", size=(15, 2)),
sg.Button("Update",
key="-UPDATE-",
size=(15, 2),
disabled=(update_version <= installed_version))
],
[
sg.T("Version: " + str(installed_version),
key="-INSTALL_VERSION-",
size=(15, 1)),
sg.T("Update: " + str(update_version),
key="-UPDATE_VERSION-",
size=(15, 1))
], [sg.Frame("Updater", update_frame)]]
return layout
def get_zone(self):
column = []
saved_key = []
for zone in self.Zones:
zone_info[zone['name']] = zone['id']
zone_list.append(zone['name'])
column.append([sg.CB(zone['name'])])
layout = [[sg.Text('Choose a zone')], [sg.Col(column)],
[sg.Button('Select'), sg.Exit()]]
window = sg.Window('All zones', layout)
while True:
event, values = window.Read()
if event is None or event == 'Exit':
break
elif event == 'Select':
for key in values:
if values[key]:
saved_key = key
break
window.Close()
print(zone_list[saved_key])
return zone_list[saved_key]
def choose_locations(locations, chosen_locations):
locations = list(locations)
if not chosen_locations:
defaults = DEFAULT_LOCATIONS
else:
defaults = chosen_locations
max_col = 7
row = []
cb_layout = []
for i, location in enumerate(sorted(locations)):
row.append(sg.CB(location, size=(15,1), pad=(1,1), font='Any 9', key=location, default=True if location in defaults else False))
if (i+1) % max_col == 0:
cb_layout += [row]
row = []
cb_layout += [row]
layout = [[sg.T('Choose Locations (max 8)')]]
layout += cb_layout
layout += [[sg.B('Ok', border_width=0, bind_return_key=True), sg.B('Cancel', border_width=0)]]
window = sg.Window('Choose Locations', layout, keep_on_top=True, border_depth=0)
event, values = window.read()
window.close()
if event == 'Ok':
locations_selected = []
for key in values.keys():
if values[key]:
locations_selected.append(key)
else:
locations_selected = chosen_locations
return locations_selected
def get_boss(self, raid_name):
column = []
saved_key = []
id_zone = zone_info[raid_name]
raid = self.Zones[id_zone - 3]['encounters']
for encounter in raid:
raid_info[encounter['name']] = encounter['id']
column.append([sg.CB(encounter['name'])])
boss_list.append(encounter['name'])
layout = [[sg.Text('Choose a boss')], [sg.Col(column)],
[sg.Button('Select'), sg.Exit()]]
window = sg.Window('All bosses', layout)
while True:
event, values = window.Read()
if event is None or event == 'Exit':
break
elif event == 'Select':
for key in values:
if values[key]:
saved_key = key
break
window.Close()
print(boss_list[saved_key])
return boss_list[saved_key]
def get_input(derate, template):
layout = [[
sg.Text('Input File (CSV)', size=(15, 1)),
sg.InputText(key='-IN-', size=(70, 1)),
sg.FileBrowse(file_types=(("CSV Files", "*.csv"), ))
],
[
sg.Text('Derating Factor', size=(15, 1)),
sg.InputText(default_text=derate,
size=(70, 1),
key='-DERATE-')
],
[
sg.Text('Template File', size=(15, 1)),
sg.InputText(default_text=template,
size=(70, 1),
key='-TMP-')
],
[
sg.Stretch(),
sg.Ok(size=(10, 1)),
sg.Cancel(size=(10, 1)),
sg.CB('Generate PowerPoint Report',
key='-PPT-',
default=True),
sg.Stretch()
]]
window = sg.Window('Select File', layout)
event, values = window.read()
window.close()
if event in (None, 'Cancel'):
exit()
return values['-IN-'], values['-TMP-'], float(
values['-DERATE-']), values['-PPT-']
def create_window(settings):
max_rows, max_cols = int(settings['rows']), int(settings['cols'])
graph_size = int(settings['graph_x_size']), int(settings['graph_y_size'])
# Create grid of Graphs with titles
graph_layout = [[]]
for row in range(max_rows):
graph_row = []
for col in range(max_cols):
graph = sg.Graph(graph_size, (0,0), DATA_SIZE, key=row*max_cols+col, pad=(0,0))
graph_row += [sg.Frame('', [[sg.T(size=(30,2), key=f'-TITLE-{row*max_cols+col}', font='helvetica 9')],[graph]], pad=(0,0))]
graph_layout += [graph_row]
if settings.get('data source','confirmed') == 'confirmed':
heading = 'COVID-19 Cases By Region '
else:
heading = 'COVID-19 Deaths By Region '
# Create the layout
layout = [[sg.T(heading, font='Any 20'),
sg.T(size=(15,1), font='Any 20', key='-DATE-')],]
layout += graph_layout
layout += [[sg.T('Way-back machine'),
sg.Slider((0,100), size=(30,15), orientation='h', enable_events=True, key='-SLIDER-'),
sg.T(f'Rewind up to 00000 days', key='-REWIND MESSAGE-'),
sg.CB('Animate Graphs', enable_events=True, key='-ANIMATE-'), sg.T('Update every'), sg.I('50', key='-ANIMATION SPEED-', enable_events=True, size=(4,1)), sg.T('milliseconds')],
[sg.CB('Enable Forecasting', default=settings.get('forecasting',False), enable_events=True, key='-FORECAST-'), sg.T(' Daily growth rate'), sg.I(str(DEFAULT_GROWTH_RATE), size=(5,1), key='-GROWTH RATE-'),
sg.T(f'Forecast up to {MAX_FORECASTED_DAYS} days'),
sg.Slider((0, MAX_FORECASTED_DAYS), default_value=1, size=(30, 15), orientation='h', enable_events=True, key='-FUTURE SLIDER-'),
]]
layout += [[sg.T('Settings', key='-SETTINGS-', enable_events=True),
sg.T(' Locations', key='-LOCATIONS-', enable_events=True),
sg.T(' Refresh', key='-REFRESH-', enable_events=True),
sg.T(' Change Settings File', key='-CHANGE SETTINGS FILENAME-', enable_events=True),
# sg.T(' Raw Data', key='-RAW DATA-', enable_events=True),
sg.T(' Exit', key='Exit', enable_events=True),
sg.T(' '*20),
sg.T(size=(40,2), font='Any 8', key='-UPDATED-'),
sg.Col([[sg.T(r'Data source: Johns Hopkins - https://github.com/CSSEGISandData/COVID-19', enable_events=True, font='Any 8', key='-SOURCE LINK-', pad=(0,0))],
[sg.T(f'Version {VERSION} Created using PySimpleGUI', font='Any 8', enable_events=True, key='-PSG LINK-', pad=(0,0))]])]
]
window = sg.Window('COVID-19 Confirmed Cases', layout, grab_anywhere=False, no_titlebar=False, margins=(0,0), icon=ICON, finalize=True)
# set cursor to hand for all text elements that looks like links
_ = [window[key].set_cursor('hand2') for key in ('-SETTINGS-', '-LOCATIONS-', '-REFRESH-', 'Exit', '-SOURCE LINK-', '-PSG LINK-')]
return window
def generateMainWindow():
pastdateFrameLayout = [
[sg.T('Date: '), sg.InputText(key='-DATE-')],
[sg.Text('Start Time: '),
sg.InputText(key='-STARTTIME-')],
[sg.Text('End Time: '),
sg.InputText(key='-ENDTIME-')]
]
metadataLayout = [[sg.T("Task: "),
sg.InputText(key='-TASK-')],
[
sg.T("Category"),
sg.Combo(categoryOptions, key='-CATEGORY-')
], [sg.T("Duration: "),
sg.InputText(key='-DURATION-')],
[sg.T('Details: '),
sg.InputText(key='-DETAILS-')]]
column1Layout = [
[
sg.CB("Debug Mode", key="-DEBUG-"),
sg.CB("See Today's Sessions", key='-SHOW SESSION-')
],
[sg.Frame("Details", metadataLayout)],
# [sg.Text("Time remaining:"),sg.Text(0, key = 'displayTimeRemaining')],
[sg.Frame("After the fact", pastdateFrameLayout)],
[sg.ProgressBar(1000, 'h', size=(40, 20), key='ProgressBar')],
[
sg.Button('Record session', key='-LOG-', disabled=True),
sg.Button("Start", key="toggleStart", disabled=True),
sg.Button("End Session", disabled=True, key="-END SESSION-"),
sg.Cancel()
]
]
column2Layout = [[sg.Text("Today so far:")], [sg.Text(getSessionInfo())]]
windowLayout = [[
sg.Column(column1Layout),
sg.Column(column2Layout, visible=False, key='-SESSION COLUMN-')
]]
return sg.Window("Record Work Session", windowLayout)
def __init__(self, agent, par_shorts=[], available_pars=[]):
self.agent = agent
self.available_pars = available_pars
self.par_shorts = par_shorts
self.dt = self.agent.model.dt
self.init_dur = 20
self.window_size = (1550, 1200)
self.canvas_size = (self.window_size[0] - 50, self.window_size[1] - 50)
self.my_dpi = 96
self.figsize = (int(self.canvas_size[0] / self.my_dpi),
int(self.canvas_size[1] / self.my_dpi))
Ncols = 4
par_lists = [
list(a) for a in np.array_split(self.available_pars, Ncols)
]
par_layout = [[sg.Text('Choose parameters')],
[
sg.Col([
*[[sg.CB(p, key=f'k_{p}')] for p in par_lists[i]]
]) for i in range(Ncols)
],
[
sg.Button('Ok', **button_kwargs),
sg.Button('Cancel', **button_kwargs)
]]
graph_layout = [
# [sg.Text(f'{self.agent.unique_id} : {self.par}', size=(40, 1), justification='center', font='Helvetica 20')],
[sg.Canvas(size=(1280, 1200), key='-CANVAS-')],
[sg.Text('Time in seconds to display on screen')],
[
sg.Slider(range=(0.1, 60),
default_value=self.init_dur,
size=(40, 10),
orientation='h',
key='-SLIDER-TIME-')
],
[sg.Button('Choose', **button_kwargs)]
]
layout = [[
sg.Column(par_layout, key='-COL1-'),
sg.Column(graph_layout, visible=False, key='-COL2-')
]]
self.window = sg.Window(f'{self.agent.unique_id} Dynamic Graph',
layout,
finalize=True,
location=(0, 0),
size=self.window_size)
self.canvas_elem = self.window.FindElement('-CANVAS-')
self.canvas = self.canvas_elem.TKCanvas
self.fig_agg = None
self.update_pars()
self.layout = 1
def make_search_row(item_number):
search_layout = [
sg.Combo(sorted(settings.get('-search string-', [])),
settings['-last search-'],
size=(45, 1),
k=('-SEARCH STRING-', item_number)),
# sg.In(key=('-SEARCH STRING-', item_number)),
sg.CB('Require', key=('-SEARCH REQUIRED-', item_number))
]
return search_layout
def get_setups_offline(self, guild_list):
file = sg.popup_get_file('Укажите сохраненные сетапы на определенного босса')
df = pd.read_csv(file)
rows = df[::-1]
column = []
path = []
for i in rows:
diff = difference(i, guild_list) # difference of the classes
percent = len(diff) / 20
if percent <= 0.2:
column.append([sg.CB(str(percent))])
path.append(rows[len(rows)])
def getSettings():
# default settings
settings = {
"safeMode": True,
"theme": 'Dark Blue',
"fileName": sg.popup_get_file('Bank statement to categorise')
}
sg.change_look_and_feel("Dark Blue")
settingsLayout = [
[
sg.CB("SafeMode",
default=True,
tooltip="Recommended for first run",
key="-SAFE MODE-")
],
[
sg.Text(
"Note: When in safemode is OFF, the program will rely on previous categorisations only."
)
],
[
sg.Text("Choose a theme (optional)"),
sg.Listbox(values=sg.theme_list(),
size=(20, 12),
key='-THEME-')
], [sg.Submit(), sg.Cancel()]
]
# extracting from the window
window = sg.Window("Choose Settings", settingsLayout)
event, values = window.read()
window.close()
# Overwriting if necessary
if event != None:
try:
settings['safeMode'] = values["-SAFE MODE-"]
if len(values["-THEME-"]) > 0:
settings['theme'] = values["-THEME-"][0]
except Exception as e:
print(e)
return settings
def get_quality(url):
global title
yt = YouTube(url, on_progress_callback=progress_callback)
streams = yt.streams
title = yt.title
layout = [[sg.T('Choose streams')]]
for i, s in enumerate(streams):
layout += [[sg.CB(str(s), k=i)]]
layout += [[sg.Ok(), sg.Cancel()]]
event, values = sg.Window('Choose Stream', layout).read(close=True)
choices = [k for k in values if values[k]]
if not choices:
sg.popup_error('Must choose stream')
exit()
return streams[choices[0]] # Return the first choice made
def get_quality(url):
yt = YouTube(url)
streams = yt.streams.all()
layout = [[sg.T('Choose Streams')]]
for i, s in enumerate(streams):
layout += [[sg.CB(str(s), k=i)]]
layout += [[sg.Ok(), sg.Cancel()]]
event, values = sg.Window('Choose Stream', layout).read(close=True)
choices = [k for k in values if values[k]]
if not choices:
sg.popup_error('Must choose stream')
exit()
else:
print(f'You chose {choices[0]}')
print(streams[choices[0]])
return streams[choices[0]]
def settings_window():
def input_line(text, key, default):
return [
sg.T(text, size=(15, 1), justification='r'),
sg.In(default, size=(20, 1), k=key)
]
layout = [
[sg.T('Reddit PRAW Settings', font='default 15')],
[
sg.
T('Note - You must register with Reddit to obtain PRAW credentials'
)
],
input_line('Client ID', '-CLIENT ID-', settings['client_id']),
input_line('Client Secret', '-CLIENT SECRET-',
settings['client_secret']),
input_line('User Agent', '-USER AGENT-', settings['user_agent']),
input_line('Username', '-USERNAME-', settings['username']),
input_line('Password', '-PASSWORD-', settings['password']),
[sg.CB('Clear Search History', k='-CLEAR HISTORY-')],
]
layout += [[sg.Ok(), sg.Cancel()]]
event, values = sg.Window('Reddit Reader Settings',
layout,
icon=reddit_icon).read(close=True)
if event == 'Ok':
settings['client_id'] = values['-CLIENT ID-']
settings['client_secret'] = values['-CLIENT SECRET-']
settings['user_agent'] = values['-USER AGENT-']
settings['username'] = values['-USERNAME-']
settings['password'] = values['-PASSWORD-']
if values['-CLEAR HISTORY-']:
settings['-search string-'] = []
return True
return False
def create_gamerule_layout():
"""Create layout for the gamerules tab.
Contains all the gamerules available for the game, grouped into a
single column. The gamerules with a boolean value are assigned a
CheckBox, and the gamerules with an integer value are assigned an
Input element
"""
logging.debug("Creating gamerule layout")
grouped = sg.Column([[]],
scrollable=True,
vertical_scroll_only=True)
for gr in gamerules.keys():
col1, col2 = sg.Sizer(20, 1), sg.Sizer(15, 1)
col2.ElementJustification = "right"
col1.add_row(sg.Text(gr, (25, 1)))
key = f"gamerules_{gr}"
if isinstance(gamerules.get(gr), bool):
col2.add_row(sg.CB("", gamerules.get(gr), key=key))
else:
col2.add_row(sg.I(gamerules.get(gr), (10, 1), key=key))
grouped.add_row(col1, col2)
return [[grouped]]
resolution=.1,
default_value=.3,
size=(15, 15),
key='-confidence-')
],
[
sg.Text('Threshold'),
sg.Slider(range=(0, 1),
orientation='h',
resolution=.1,
default_value=.5,
size=(15, 15),
key='-threshold-')
],
[
sg.CB(text='GPU', default=False, enable_events=True, key='-GPU-'),
sg.CB('Save label', default=True, enable_events=True, key='-LABEL-'),
sg.CB('Save image',
default=False,
enable_events=True,
key='-img_save-')
], [sg.Button('Run')], [sg.Text('_' * 60)],
[
sg.Txt(
'Step 2 (optional) : Export dataset in YOLO format ready to train')
],
[
sg.Text('Export dataset: '),
sg.In('export', size=(40, 1), key='-export-'),
sg.FolderBrowse()
], [sg.Button('Export')]
def main(_file=None):
"""
This function is the entry point to the renderer.
Pass in the file you want to to have it in the file inputbox by default.
for e.g.:
`main(__file__)`
"""
_File = "" if _file is None else _file
menu_def = [
[
"&Open",
["&File", "&Media dir", ["&Tex", "&Videos"]],
],
[
"O&ptions",
["&Add folder to sys.path", "&Show path"],
],
]
layout = [
[sg.Menu(menu_def)],
[
sg.T("Choose file: "),
sg.Input(_File, key="path", size=(100, 1)),
sg.FileBrowse(target="path", key="get_file"),
],
[
sg.T("Scenes found:"),
sg.Listbox(
["No scenes found"],
size=(70, 12),
select_mode=sg.LISTBOX_SELECT_MODE_MULTIPLE,
enable_events=True,
key="scene_select",
),
sg.B("Get Scenes", button_color=("black", "yellow")),
],
[
sg.T(" " * 20),
sg.B("Select All", key="select_all"),
sg.B("Clear selection", key="clear"),
],
[
sg.T("Scene(s) selected :"),
sg.T("No scene selected", size=(100, 5), key="scene"),
],
[
sg.T("Quality: "),
sg.Radio("low", key="l", group_id="quality", default=True),
sg.Radio("medium", key="m", group_id="quality"),
sg.Radio("high", key="h", group_id="quality"),
sg.Radio("production", key="p", group_id="quality"),
sg.Radio("4K", key="k", group_id="quality"),
],
[
sg.T("Format: "),
sg.Radio("mp4", key="w", group_id="format", default=True),
sg.Radio("png", key="g", group_id="format", default=False),
sg.Radio("gif", key="i", group_id="format", default=False),
sg.Checkbox("Transparent", key="t", default=False)
],
[
sg.T("Other :"),
sg.Checkbox("Preview?", default=True, key="preview_bool"),
sg.Checkbox("Leave progress bars?", default=True, key="lpb_bool"),
sg.Checkbox("Show in Explorer?",
default=True,
key="show_in_browser_bool")
],
[
sg.T("Specify animation "),
sg.CB("start number?", key="n1_bool"),
sg.CB("end number?", key="n2_bool"),
],
[
sg.T("Start at animation number"),
sg.Spin(list(range(10000)), 0, True, key="n1"),
sg.T("End at animation number"),
sg.Spin(list(range(10000)), 0, True, key="n2"),
sg.B("Refresh", button_color=("black", "yellow")),
],
[sg.T()],
[
sg.T("Media Folder: "),
sg.Checkbox("Custom Media folder",
default=False,
key="custom_media_folder_bool"),
sg.Input(_File, key="media_path", size=(100, 1)),
sg.FolderBrowse(target="media_path", key="get_folder"),
],
[sg.T()],
[sg.T("Status: "),
sg.T("IDLE", key="status", size=(30, 1))],
[sg.B("RENDER", button_color=("black", "green"))],
]
# sg.theme_previewer()
manim_gui = sg.Window(
"Manim Renderer v0.2 - Modified by allemand-instable",
layout,
resizable=True,
icon=
MANIM_LOGO_BASE64, ## TODO: Figure out why the icon doesn't display in the taskbar
)
console.print("Opened.")
while True:
try:
event, values = manim_gui.read()
if event != sg.TIMEOUT_KEY:
## Uncomment these if debugging
# console.print(f"Event: {event}")
# console.print(f"Values {values}")
pass
if event in (None, "Exit"):
break
if event == "Get Scenes":
File = values["path"]
os.chdir(Path(File).parent)
# console.print(os.getcwd())
if not has_spaces(File):
scenes = find_scenes(File)
console.print(scenes)
manim_gui["scene_select"].Update(values=scenes)
else:
sg.PopupError("Error: Spaces in file path",
title="SpacesError")
if event == "scene_select":
manim_gui["scene"].Update(", ".join(values["scene_select"]))
if event == "Refresh":
manim_gui["n1"].Update(value=0, disabled=not values["n1_bool"])
manim_gui["n2"].Update(value=0, disabled=not values["n2_bool"])
manim_gui.read(timeout=0)
# Render Code
# -----------
if event == "RENDER":
# scene = " ".join(values["scene_select"])
# console.print(scene)
# console.print(quality)
# console.print(args)
start_time = time.time()
manim_gui["status"].Update("Rendering")
manim_gui.read(timeout=0)
## This is where the multiple rendering thing takes place if applicable
for scene in values["scene_select"]:
values.pop(0, None)
# console.print(scene, values) ## Use while debugging
render(scene, **values)
# console.print(output)
sg.SystemTray.notify("Render complete",
"Check console for more details")
manim_gui["status"].Update("Rendered")
end_time = time.time()
render_time = math.trunc(end_time - start_time)
console.print(f"Render complete in {render_time}s ")
console.print("\n" + "[green]+[/green]-[green]+[/green]" *
(os.get_terminal_size().columns // 3))
console.print("\n\n")
if event == "select_all":
manim_gui["scene_select"].Update(
set_to_index=list(range(len(scenes))))
manim_gui.read()
manim_gui["scene"].Update(", ".join(values["scene_select"]))
if event == "clear":
manim_gui["scene_select"].Update(set_to_index=False)
manim_gui.read()
manim_gui["scene"].Update("")
## Menu options
if event == "File":
file_path = sg.popup_get_file("Select file with manim scenes",
no_window=True)
manim_gui["path"].update(file_path)
os.chdir(Path(file_path).parent)
# console.print(os.getcwd())
manim_gui.refresh()
if event == "Tex":
os.system("explorer .\\media\\Tex")
if event == "videos":
os.system("explorer .\\media\\videos")
if event == "Add folder to sys.path":
folder_getter = sg.popup_get_folder("Add folder",
no_window=True)
sys.path.append(folder_getter)
manim_gui.refresh()
if event == "Show path":
sg.popup(*sys.path, title="sys.path")
except Exception as e:
console.print_exception()
sg.PopupError(e, title="Error")
finally:
manim_gui.refresh()
manim_gui.close()
def run_gui():
def clear_empty_top_widget(ui):
'''
clear ui to easyily for coping functionality (ctrl+c)
'''
'''
# case1
sg.Frame('', key='gridLayout', layout = [
[sg.RButton('PushButton', key='pushButton'), sg.RButton('PushButton', key='pushButton_2')]
])
'''
first_line = ui.split('\n')[0]
regex_matched = make_regex(
r"^sg.Frame\('',\s?key='.*',\slayout\s=\s\[").match(first_line)
if regex_matched and ui[-2:] == '])':
new_ui = '[\n' + '\n'.join(ui.split('\n')[1:]).strip()
return new_ui[:-1]
return ui
def update_clear_btn(my_window, my_values, real_value=''):
objname = my_values['objname'] if real_value == '' else real_value
all_object_names_in_combo = my_window.Element('objs').Values
if my_values[
'xmlfile'] and objname and objname in all_object_names_in_combo:
my_window.Element('compile_btn').Update(disabled=False)
my_window.Element('compilepp_btn').Update(disabled=False)
else:
my_window.Element('compile_btn').Update(disabled=True)
my_window.Element('compilepp_btn').Update(disabled=True)
# _
# (_)
# __ _ _ _ _
# / _` | | | | |
# | (_| | |_| | |
# \__, |\__,_|_|
# __/ |
# |___/
ralign = {'size': (16, 3), "justification": 'r'}
input_frame = [[
sg.T('\nxml file', **ralign),
sg.In(key='xmlfile', change_submits=True),
sg.FileBrowse(target='xmlfile'),
sg.T('possible\nobject names', justification='r'),
sg.InputCombo(values=[''],
key='objs',
size=(40, 1),
change_submits=True)
],
[
sg.T('\nTarget object name', **ralign),
sg.In(key='objname', change_submits=True),
sg.B('compile', key='compile_btn', disabled=True),
sg.B('compile++', key='compilepp_btn', disabled=True),
sg.Radio('all keys', 1, True, key='r2_keys'),
sg.Radio('mouse clicks', 1, key='r2_mouse_clicks')
]]
tab1_layout = [[sg.Frame('Input data', input_frame)],
[
sg.B('Clear'),
sg.CB('forget about bad widgets',
True,
key='no_bad_widgets'),
sg.CB('empty top widget', True, key='empty_top_widget')
], [sg.Multiline(key='psg_ui_output', size=(120, 14))]]
tab2_layout = [[sg.Image(filename='', key='psg_image')]]
layout = [[
sg.TabGroup([[
sg.Tab('transpiler', tab1_layout),
sg.Tab('hot transpiler', tab2_layout, disabled=True)
]])
]]
window = sg.Window('Transpiler',
layout=layout,
auto_size_buttons=False,
default_button_element_size=(10, 1))
while True: # Event Loop
event, values = window.Read()
# window.Element('psg_image').Update(filename='imgs/' + random.choice('1.png 2.png 3.png 4.png'.split(' ')))
if event in (None, 'Exit'):
break
elif event == 'xmlfile':
myxml_file = values['xmlfile']
if os.path.exists(myxml_file):
# get xml
with open(myxml_file, 'r', encoding='utf-8') as ff:
xml_code = ff.read()
# filter object names
widgets_regexpattern = make_regex(
r"^[ \s]{1,}<(widget)\s?.*?\s?name=\"(.+)\"\/?>",
MULTILINE)
layouts_regexpattern = make_regex(
r"^[ \s]{1,}<(layout)\s?.*?\s?name=\"(.+)\"\/?>",
MULTILINE)
widgets = [
i.group(2)
for i in finditer(widgets_regexpattern, xml_code)
]
layouts = [
i.group(2)
for i in finditer(layouts_regexpattern, xml_code)
]
combo_items = [
'# LAYOUTS widgets #', *layouts, '# WIDGETS widgets #',
*widgets
]
# set it
window.Element('objs').Update(values=combo_items)
update_clear_btn(window, values)
el = combo_items[1]
if ' ' not in el:
window.Element('objname').Update(el)
update_clear_btn(window, values, real_value=el)
elif event == 'objs':
# add only REAL object names -> those, who not contain ' '
if ' ' not in values['objs']:
window.Element('objname').Update(values['objs'])
update_clear_btn(window, values, real_value=values['objs'])
elif event == 'objname':
update_clear_btn(window, values)
elif event == 'Clear':
window.Element('psg_ui_output').Update('')
elif event == 'compile_btn':
ui = just_compile(values)
if values['empty_top_widget']:
ui = clear_empty_top_widget(ui)
window.Element('psg_ui_output').Update(ui)
elif event == 'compilepp_btn':
ui = just_compile(values)
# case for 'speed up'
# psg_ui_output = values['psg_ui_output']
# ui = ... psg_ui_output ...
ui = just_compile(values)
if values['empty_top_widget']:
ui = clear_empty_top_widget(ui)
psg_ui = build_boilerplate(layout=ui,
mouse_clicks=values['r2_mouse_clicks'],
keys=values['r2_keys'])
window.Element('psg_ui_output').Update(psg_ui)
elif event == 'Try in PySimpleGUI':
pass
# try:
# ui = values['psg_ui_output'].strip()
# if ui[:18] == "sg.Frame('', key='" and ui[-2:] == "])":
# ui = ui[ui.index('['):-1]
# elif ui[0] == "[" and ui[-1] == "]":
# pass
# window2 = sg.Window('test', myui)
# window2.Read()
# window2.Close()
# except Exception as e:
# mbox(str(e))
window.Close()
[sg.Text("判断stub消息的offset是否递增", auto_size_text=True),
sg.Button(button_text="Get6", button_color=('black', 'blue'), pad=(100, 3), size=(10, 1))],
[sg.Text("判断stub消息在重构时是否发送", auto_size_text=True),
sg.Button(button_text="Get7", button_color=('black', 'blue'), pad=(93, 3), size=(10, 1))],
[sg.Text("判断segment消息是否重发", auto_size_text=True),
sg.Button(button_text="Get8", button_color=('black', 'blue'), pad=(120, 3), size=(10, 1))],
[sg.Text("判断各个消息是否丢包", auto_size_text=True),
sg.Button(button_text="Get9", button_color=('black', 'blue'), pad=(144, 3), size=(10, 1))]
]
# ------------------------- Action ---------------------------- #
frame3_layout = [
[sg.T("Some ohter action ", auto_size_text=True)],
[sg.Text("生成Issue状态报表", auto_size_text=True),
sg.Button(button_text="Do it", button_color=('black', 'blue'), pad=(173, 3), size=(10, 1))],
[sg.Text("删除无用的log", auto_size_text=True)],
[sg.CB('Release log'), sg.CB('Input log'), sg.CB('Output log'),
sg.Button(button_text="Delete it", button_color=('black', 'blue'), pad=(7, 3), size=(10, 1))],
[sg.Text("按照offset和path id的规则来显示slope", auto_size_text=True)],
[sg.Radio("mode 2", 'RADIO1', default=True), sg.Radio("mode 3", 'RADIO1'),
sg.Button(button_text="Show it", button_color=('black', 'blue'), pad=(135, 3), size=(10, 1)),
sg.Button(button_text='Close show', button_color=('black', 'blue'), size=(10, 1))],
]
# -------------------------- main layout ---------------------- #
layout = [
[sg.Menu(menu_def, tearoff=True)],
[sg.Text('请输入即将创建的日志文件名 :', auto_size_text=True), sg.InputText(key='-IN-'),
sg.Button(button_text="创建文件夹", button_color=('black', 'blue'), size=(10, 1)),
sg.Button(button_text='环境检测', button_color=('black', 'red'), size=(25, 1)),
sg.Button(button_text='环境设置', button_color=('black', 'yellow'), size=(10, 1))],
[sg.Frame('操作 Log', frame1_layout, font='Any 12', title_color='blue', title_location='n'),
def PCoA_analysis(TaXon_table_xlsx, meta_data_to_test, taxonomic_level, width,
height, pcoa_s, path_to_outdirs, template, font_size,
color_discrete_sequence, pcoa_dissimilarity):
import pandas as pd
import numpy as np
from skbio.diversity import beta_diversity
from skbio.stats.ordination import pcoa
from skbio.stats.distance import anosim
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly.express as px
from pathlib import Path
import PySimpleGUI as sg
import os, webbrowser
from itertools import combinations
TaXon_table_xlsx = Path(TaXon_table_xlsx)
Meta_data_table_xlsx = Path(
str(path_to_outdirs) + "/" + "Meta_data_table" + "/" +
TaXon_table_xlsx.stem + "_metadata.xlsx")
TaXon_table_df = pd.read_excel(TaXon_table_xlsx,
header=0).fillna("unidentified")
TaXon_table_samples = TaXon_table_df.columns.tolist()[10:]
Meta_data_table_df = pd.read_excel(Meta_data_table_xlsx,
header=0).fillna("nan")
Meta_data_table_samples = Meta_data_table_df['Samples'].tolist()
metadata_list = Meta_data_table_df[meta_data_to_test].values.tolist()
metadata_loc = Meta_data_table_df.columns.tolist().index(meta_data_to_test)
## drop samples with metadata called nan (= empty)
drop_samples = [
i[0] for i in Meta_data_table_df.values.tolist()
if i[metadata_loc] == "nan"
]
if drop_samples != []:
## filter the TaXon table
TaXon_table_df = TaXon_table_df.drop(drop_samples, axis=1)
TaXon_table_samples = TaXon_table_df.columns.tolist()[10:]
## also remove empty OTUs
row_filter_list = []
for row in TaXon_table_df.values.tolist():
reads = set(row[10:])
if reads != {0}:
row_filter_list.append(row)
columns = TaXon_table_df.columns.tolist()
TaXon_table_df = pd.DataFrame(row_filter_list, columns=columns)
Meta_data_table_df = pd.DataFrame(
[
i for i in Meta_data_table_df.values.tolist()
if i[0] not in drop_samples
],
columns=Meta_data_table_df.columns.tolist())
Meta_data_table_samples = Meta_data_table_df['Samples'].tolist()
## create a y axis title text
taxon_title = taxonomic_level.lower()
## adjust taxonomic level if neccessary
if taxonomic_level in ["ASVs", "ESVs", "OTUs", "zOTUs"]:
taxon_title = taxonomic_level
taxonomic_level = "ID"
# check if the meta data differs
if len(set(Meta_data_table_df[meta_data_to_test])) == len(
Meta_data_table_df['Samples'].tolist()):
sg.Popup(
"The meta data is unique for all samples. Please adjust the meta data table!",
title=("Error"))
raise RuntimeError
# check if the meta data differs
if len(set(Meta_data_table_df[meta_data_to_test])) == 1:
sg.Popup(
"The meta data is similar for all samples. Please adjust the meta data table!",
title=("Error"))
raise RuntimeError
if sorted(TaXon_table_samples) == sorted(Meta_data_table_samples):
samples = Meta_data_table_samples
## extract the relevant data
TaXon_table_df = TaXon_table_df[[taxonomic_level] + samples]
## define an aggregation function to combine multiple hit of one taxonimic level
aggregation_functions = {}
## define samples functions
for sample in samples:
## 'sum' will calculate the sum of p/a data
aggregation_functions[sample] = 'sum'
## define taxon level function
aggregation_functions[taxonomic_level] = 'first'
## create condensed dataframe
TaXon_table_df = TaXon_table_df.groupby(
TaXon_table_df[taxonomic_level]).aggregate(aggregation_functions)
if 'unidentified' in TaXon_table_df.index:
TaXon_table_df = TaXon_table_df.drop('unidentified')
data = TaXon_table_df[samples].transpose().values.tolist()
jc_dm = beta_diversity(pcoa_dissimilarity, data, samples)
ordination_result = pcoa(jc_dm)
metadata_list = Meta_data_table_df[meta_data_to_test].values.tolist()
anosim_results = anosim(jc_dm, metadata_list, permutations=999)
anosim_r = round(anosim_results['test statistic'], 5)
anosim_p = anosim_results['p-value']
textbox = meta_data_to_test + ", " + taxon_title + "<br>Anosim " + "R = " + str(
anosim_r) + " " + "p = " + str(anosim_p)
#######################################################################################
# create window to ask for PCoA axis to test
def slices(list, slice):
for i in range(0, len(list), slice):
yield list[i:i + slice]
# collect the PCoA proportion explained values
proportion_explained_list = []
for i, pcoa_axis in enumerate(ordination_result.proportion_explained):
if round(pcoa_axis * 100, 2) >= 1:
proportion_explained_list.append("PC" + str(i + 1) + " (" +
str(round(pcoa_axis *
100, 2)) + " %)")
pcoa_axis_checkboxes = list(
slices([
sg.Checkbox(name, key=name, size=(15, 1))
for name in proportion_explained_list
], 10))
pcoa_window_layout = [
[sg.Text('Check up to four axes to be displayed')],
[sg.Frame(layout=pcoa_axis_checkboxes, title='')],
[sg.Text('Only axes >= 1 % explained variance are shown')],
[sg.CB("Connect categories", default=True, key="draw_mesh")],
[sg.Text('')],
[sg.Button('Plot', key='Plot')],
[sg.Button('Back')],
]
pcoa_window = sg.Window('PCoA axis',
pcoa_window_layout,
keep_on_top=True)
while True:
event, values = pcoa_window.read()
draw_mesh = values["draw_mesh"]
if event is None or event == 'Back':
break
if event == 'Plot':
## create a subfolder for better sorting and overview
dirName = Path(
str(path_to_outdirs) + "/" + "PCoA_plots" + "/" +
TaXon_table_xlsx.stem + "/")
if not os.path.exists(dirName):
os.mkdir(dirName)
# collect the pcoa axis values
axis_to_plot = [
key for key, value in values.items()
if value == True and "PC" in key
]
# pass on only if two pcoa axes were checked
if len(axis_to_plot) == 2:
cat1 = axis_to_plot[1].split()[0]
cat2 = axis_to_plot[0].split()[0]
df_pcoa = ordination_result.samples[[cat1, cat2]]
df_pcoa.insert(
2, "Metadata",
Meta_data_table_df[meta_data_to_test].values.tolist(),
True)
df_pcoa.insert(
3, "Samples",
Meta_data_table_df["Samples"].values.tolist(), True)
if draw_mesh == True:
combinations_list = []
for metadata in df_pcoa["Metadata"]:
## collect all entries for the respective metadata
arr = df_pcoa.loc[df_pcoa['Metadata'] == metadata][
[cat1, cat2, "Metadata",
"Samples"]].to_numpy()
## create a df for all possible combinations using itertools combinations
for entry in list(combinations(arr, 2)):
combinations_list.append(list(entry[0]))
combinations_list.append(list(entry[1]))
## create a dataframe to draw the plot from
df = pd.DataFrame(combinations_list)
df.columns = [cat1, cat2, "Metadata", "Samples"]
fig = px.scatter(
df,
x=cat1,
y=cat2,
color="Metadata",
text="Samples",
title=textbox,
color_discrete_sequence=color_discrete_sequence)
fig.update_traces(marker_size=int(pcoa_s),
mode="markers+lines")
fig.update_layout(height=int(height),
width=int(width),
template=template,
showlegend=True,
font_size=font_size,
title_font_size=font_size)
fig.update_xaxes(title=axis_to_plot[1])
fig.update_yaxes(title=axis_to_plot[0])
else:
fig = px.scatter(
df_pcoa,
x=cat1,
y=cat2,
color="Metadata",
text="Samples",
title=textbox,
color_discrete_sequence=color_discrete_sequence)
fig.update_traces(marker_size=int(pcoa_s),
mode="markers")
fig.update_layout(height=int(height),
width=int(width),
template=template,
showlegend=True,
font_size=font_size,
title_font_size=font_size)
fig.update_xaxes(title=axis_to_plot[1])
fig.update_yaxes(title=axis_to_plot[0])
## define output files
output_pdf = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + ".pdf")
output_html = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + ".html")
output_xlsx = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + ".xlsx")
## write files
fig.write_image(str(output_pdf))
fig.write_html(str(output_html))
ordination_result.samples[[cat1,
cat2]].to_excel(output_xlsx)
## ask to show file
answer = sg.PopupYesNo('Show plot?', keep_on_top=True)
if answer == "Yes":
webbrowser.open('file://' + str(output_html))
## print closing text
closing_text = "\n" + "PCoA plots are found in: " + str(
path_to_outdirs) + "/PCoA_plots/"
sg.Popup(closing_text, title="Finished", keep_on_top=True)
## write to log
from taxontabletools.create_log import ttt_log
ttt_log("pcoa analysis", "analysis", TaXon_table_xlsx.name,
output_pdf.name, meta_data_to_test,
path_to_outdirs)
break
elif len(axis_to_plot) == 3:
cat1 = axis_to_plot[0].split()[0]
cat2 = axis_to_plot[1].split()[0]
cat3 = axis_to_plot[2].split()[0]
df_pcoa = ordination_result.samples[[cat1, cat2, cat3]]
df_pcoa.insert(
3, "Metadata",
Meta_data_table_df[meta_data_to_test].values.tolist(),
True)
df_pcoa.insert(
4, "Samples",
Meta_data_table_df["Samples"].values.tolist(), True)
## check if lines are to be drawn between the dots
if draw_mesh == True:
combinations_list = []
for metadata in df_pcoa["Metadata"]:
## collect all entries for the respective metadata
arr = df_pcoa.loc[df_pcoa['Metadata'] == metadata][
[cat1, cat2, cat3, "Metadata",
"Samples"]].to_numpy()
## create a df for all possible combinations using itertools combinations
for entry in list(combinations(arr, 2)):
combinations_list.append(list(entry[0]))
combinations_list.append(list(entry[1]))
## create a dataframe to draw the plot from
df = pd.DataFrame(combinations_list)
df.columns = [cat1, cat2, cat3, "Metadata", "Samples"]
## draw the plot
fig = px.scatter_3d(
df,
x=cat1,
y=cat2,
z=cat3,
color="Metadata",
text="Samples",
title=textbox,
color_discrete_sequence=color_discrete_sequence)
fig.update_traces(marker_size=int(pcoa_s),
mode="markers+lines",
line=dict(width=0.5))
fig.update_layout(height=int(height),
width=int(width),
template=template,
title=textbox,
showlegend=True,
font_size=font_size,
title_font_size=font_size)
fig.update_layout(
scene=dict(xaxis_title=axis_to_plot[0],
yaxis_title=axis_to_plot[1],
zaxis_title=axis_to_plot[2]))
else:
fig = px.scatter_3d(
df_pcoa,
x=cat1,
y=cat2,
z=cat3,
color="Metadata",
text="Samples",
color_discrete_sequence=color_discrete_sequence)
fig.update_traces(marker_size=int(pcoa_s),
mode="markers")
fig.update_layout(height=int(height),
width=int(width),
template=template,
showlegend=True,
title=textbox,
font_size=font_size,
title_font_size=font_size)
fig.update_layout(
scene=dict(xaxis_title=axis_to_plot[0],
yaxis_title=axis_to_plot[1],
zaxis_title=axis_to_plot[2]))
## define output files
output_pdf = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + "_3d.pdf")
output_html = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + "_3d.html")
output_xlsx = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + "_3d.xlsx")
## write output files
fig.write_image(str(output_pdf))
fig.write_html(str(output_html))
ordination_result.samples[[cat1,
cat2]].to_excel(output_xlsx)
## ask to show file
answer = sg.PopupYesNo('Show plot?', keep_on_top=True)
if answer == "Yes":
webbrowser.open('file://' + str(output_html))
## print closing text
closing_text = "PCoA plots are found in: " + str(
path_to_outdirs) + "/PCoA_plots/"
sg.Popup(closing_text, title="Finished", keep_on_top=True)
## write log file
from taxontabletools.create_log import ttt_log
ttt_log("pcoa analysis", "analysis", TaXon_table_xlsx.name,
output_pdf.name, meta_data_to_test,
path_to_outdirs)
break
else:
sg.Popup("Please choose not more than 3 PCoA axes",
title="Error",
keep_on_top=True)
if event == 'Plot matrix':
if len(proportion_explained_list) >= 4:
## create a subfolder for better sorting and overview
dirName = Path(
str(path_to_outdirs) + "/" + "PCoA_plots" + "/" +
TaXon_table_xlsx.stem + "/")
if not os.path.exists(dirName):
os.mkdir(dirName)
df_pcoa = ordination_result.samples[[
"PC1", "PC2", "PC3", "PC4"
]]
df_pcoa.insert(
4, "Metadata",
Meta_data_table_df[meta_data_to_test].values.tolist(),
True)
df_pcoa.insert(
5, "Sample",
Meta_data_table_df["Samples"].values.tolist(), True)
fig = make_subplots(rows=4, cols=4)
########### 1 ###########
fig.add_trace(go.Scatter(), row=1, col=1)
fig.update_layout(template=template,
font_size=font_size,
title_font_size=font_size)
text = "PC1 (" + str(
round(
ordination_result.proportion_explained["PC1"] *
100, 2)) + " %)"
fig.add_annotation(text=text, showarrow=False)
fig.update_xaxes(showticklabels=False, showgrid=False)
fig.update_yaxes(showticklabels=False, showgrid=False)
########### 2 ###########
df = df_pcoa[["PC1", "PC2", "Metadata", "Sample"]]
for metadata in set(metadata_list):
df_metadata = df[df['Metadata'] == metadata]
#fig = px.scatter(df_pcoa, x="PC1", y="PC2", , )
fig.add_trace(go.Scatter(
x=df_metadata["PC1"].values.tolist(),
y=df_metadata["PC2"].values.tolist(),
mode='markers',
name=metadata,
text=df_metadata["Sample"].values.tolist()),
row=1,
col=2)
########### 3 ###########
df = df_pcoa[["PC1", "PC3", "Metadata", "Sample"]]
for metadata in set(metadata_list):
df_metadata = df[df['Metadata'] == metadata]
#fig = px.scatter(df_pcoa, x="PC1", y="PC2", , )
fig.add_trace(go.Scatter(
x=df_metadata["PC1"].values.tolist(),
y=df_metadata["PC3"].values.tolist(),
mode='markers',
name=metadata,
showlegend=False,
text=df_metadata["Sample"].values.tolist()),
row=1,
col=3)
########### 4 ###########
df = df_pcoa[["PC1", "PC4", "Metadata", "Sample"]]
for metadata in set(metadata_list):
df_metadata = df[df['Metadata'] == metadata]
fig.add_trace(go.Scatter(
x=df_metadata["PC1"].values.tolist(),
y=df_metadata["PC4"].values.tolist(),
mode='markers',
name=metadata,
showlegend=False,
text=df_metadata["Sample"].values.tolist()),
row=1,
col=4)
fig.update_traces(marker_size=int(pcoa_s),
mode="markers")
fig.update_xaxes(showgrid=False, row=1, col=4)
fig.update_yaxes(showgrid=False, row=1, col=4)
########### 5 ###########
fig.add_trace(go.Scatter(), row=2, col=2)
fig.update_layout(template=template,
font_size=font_size,
title_font_size=font_size)
text = "PC2 (" + str(
round(
ordination_result.proportion_explained["PC2"] *
100, 2)) + " %)"
fig.add_annotation(text=text,
showarrow=False,
row=2,
col=2)
########### 6 ###########
df = df_pcoa[["PC2", "PC3", "Metadata", "Sample"]]
for metadata in set(metadata_list):
df_metadata = df[df['Metadata'] == metadata]
#fig = px.scatter(df_pcoa, x="PC1", y="PC2", , )
fig.add_trace(go.Scatter(
x=df_metadata["PC2"].values.tolist(),
y=df_metadata["PC3"].values.tolist(),
mode='markers',
name=metadata,
showlegend=False,
text=df_metadata["Sample"].values.tolist()),
row=2,
col=3)
########### 7 ###########
df = df_pcoa[["PC2", "PC4", "Metadata", "Sample"]]
for metadata in set(metadata_list):
df_metadata = df[df['Metadata'] == metadata]
fig.add_trace(go.Scatter(
x=df_metadata["PC2"].values.tolist(),
y=df_metadata["PC4"].values.tolist(),
mode='markers',
name=metadata,
showlegend=False,
text=df_metadata["Sample"].values.tolist()),
row=2,
col=4)
########### 8 ###########
fig.add_trace(go.Scatter(), row=3, col=3)
fig.update_layout(template=template,
font_size=font_size,
title_font_size=font_size)
text = "PC3 (" + str(
round(
ordination_result.proportion_explained["PC3"] *
100, 2)) + " %)"
fig.add_annotation(text=text,
showarrow=False,
row=3,
col=3)
########### 9 ###########
df = df_pcoa[["PC3", "PC4", "Metadata", "Sample"]]
for metadata in set(metadata_list):
df_metadata = df[df['Metadata'] == metadata]
#fig = px.scatter(df_pcoa, x="PC1", y="PC2", , )
fig.add_trace(go.Scatter(
x=df_metadata["PC3"].values.tolist(),
y=df_metadata["PC4"].values.tolist(),
mode='markers',
name=metadata,
showlegend=False,
text=df_metadata["Sample"].values.tolist()),
row=3,
col=4)
########### 5 ###########
fig.add_trace(go.Scatter(), row=4, col=4)
fig.update_layout(template=template,
font_size=font_size,
title_font_size=font_size)
text = "PC4 (" + str(
round(
ordination_result.proportion_explained["PC4"] *
100, 2)) + " %)"
fig.add_annotation(text=text,
showarrow=False,
row=4,
col=4)
######################
fig.update_xaxes(showline=True,
mirror=True,
linewidth=1,
linecolor='black')
fig.update_yaxes(showline=True,
mirror=True,
linewidth=1,
linecolor='black')
fig.update_traces(marker_size=int(pcoa_s), mode="markers")
# finish plot matrix
fig.update_layout(height=1000,
width=1000,
title_text=textbox)
## define output files
output_pdf = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + "_matrix.pdf")
output_html = Path(
str(dirName) + "/" + meta_data_to_test + "_" +
taxon_title + "_matrix.html")
## write output files
fig.write_image(str(output_pdf))
fig.write_html(str(output_html))
## ask to show file
answer = sg.PopupYesNo('Show plot?', keep_on_top=True)
if answer == "Yes":
webbrowser.open('file://' + str(output_html))
## print closing text
closing_text = "\n" + "PCoA plots are found in: " + str(
path_to_outdirs) + "/PCoA_plots/"
sg.Popup(closing_text, title="Finished", keep_on_top=True)
## write to log file
from taxontabletools.create_log import ttt_log
ttt_log("pcoa analysis", "analysis", TaXon_table_xlsx.name,
output_pdf.name, meta_data_to_test,
path_to_outdirs)
break
else:
sg.Popup(
"There must be at least 4 PCoA axis available to plot the matrix!"
)
pcoa_window.close()
else:
sg.PopupError(
"The sample of both the TaXon table and the metadata table have to match!"
)
def make_window():
"""
Creates the main window
:return: The main window object
:rtype: (sg.Window)
"""
theme = get_theme()
if not theme:
theme = sg.OFFICIAL_PYSIMPLEGUI_THEME
sg.theme(theme)
# First the window layout...2 columns
find_tooltip = "Find in file\nEnter a string in box to search for string inside of the files.\nFile list will update with list of files string found inside."
filter_tooltip = "Filter files\nEnter a string in box to narrow down the list of files.\nFile list will update with list of files with string in filename."
find_re_tooltip = "Find in file using Regular Expression\nEnter a string in box to search for string inside of the files.\nSearch is performed after clicking the FindRE button."
left_col = sg.Column([
[
sg.Listbox(values=get_file_list(),
select_mode=sg.SELECT_MODE_EXTENDED,
size=(50, 20),
bind_return_key=True,
key='-DEMO LIST-')
],
[
sg.Text('Filter (F1):', tooltip=filter_tooltip),
sg.Input(size=(25, 1),
focus=True,
enable_events=True,
key='-FILTER-',
tooltip=filter_tooltip),
sg.T(size=(15, 1), k='-FILTER NUMBER-')
],
[
sg.Button('Run'),
sg.B('Edit'),
sg.B('Clear'),
sg.B('Open Folder'),
sg.B('Copy Path')
],
[
sg.Text('Find (F2):', tooltip=find_tooltip),
sg.Input(size=(25, 1),
enable_events=True,
key='-FIND-',
tooltip=find_tooltip),
sg.T(size=(15, 1), k='-FIND NUMBER-')
],
],
element_justification='l',
expand_x=True,
expand_y=True)
lef_col_find_re = sg.pin(
sg.Col([[
sg.Text('Find (F3):', tooltip=find_re_tooltip),
sg.Input(size=(25, 1), key='-FIND RE-', tooltip=find_re_tooltip),
sg.B('Find RE')
]],
k='-RE COL-'))
right_col = [
[
sg.Multiline(size=(70, 21),
write_only=True,
key=ML_KEY,
reroute_stdout=True,
echo_stdout_stderr=True,
reroute_cprint=True)
],
[sg.B('Settings'), sg.Button('Exit')],
[sg.T('Demo Browser Ver ' + __version__)],
[
sg.T('PySimpleGUI ver ' + sg.version.split(' ')[0] +
' tkinter ver ' + sg.tclversion_detailed,
font='Default 8',
pad=(0, 0))
],
[sg.T('Python ver ' + sys.version, font='Default 8', pad=(0, 0))],
[
sg.T('Interpreter ' + sg.execute_py_get_interpreter(),
font='Default 8',
pad=(0, 0))
],
]
options_at_bottom = sg.pin(sg.Column([[
sg.CB('Verbose',
enable_events=True,
k='-VERBOSE-',
tooltip='Enable to see the matches in the right hand column'),
sg.CB('Show only first match in file',
default=True,
enable_events=True,
k='-FIRST MATCH ONLY-',
tooltip='Disable to see ALL matches found in files'),
sg.CB('Find ignore case',
default=True,
enable_events=True,
k='-IGNORE CASE-'),
sg.CB('Wait for Runs to Complete',
default=False,
enable_events=True,
k='-WAIT-')
]],
pad=(0, 0),
k='-OPTIONS BOTTOM-',
expand_x=True,
expand_y=False),
expand_x=True,
expand_y=False)
choose_folder_at_top = sg.pin(
sg.Column([[
sg.
T('Click settings to set top of your tree or choose a previously chosen folder'
),
sg.Combo(sorted(sg.user_settings_get_entry('-folder names-', [])),
default_value=sg.user_settings_get_entry(
'-demos folder-', ''),
size=(50, 30),
key='-FOLDERNAME-',
enable_events=True,
readonly=True)
]],
pad=(0, 0),
k='-FOLDER CHOOSE-'))
# ----- Full layout -----
layout = [
[sg.Text('PySimpleGUI Demo Program & Project Browser', font='Any 20')],
[choose_folder_at_top],
# [sg.Column([[left_col],[ lef_col_find_re]], element_justification='l', expand_x=True, expand_y=True), sg.Column(right_col, element_justification='c', expand_x=True, expand_y=True)],
[
sg.Pane([
sg.Column([[left_col], [lef_col_find_re]],
element_justification='l',
expand_x=True,
expand_y=True),
sg.Column(right_col,
element_justification='c',
expand_x=True,
expand_y=True)
],
orientation='h',
relief=sg.RELIEF_SUNKEN,
k='-PANE-')
],
[options_at_bottom]
]
# --------------------------------- Create Window ---------------------------------
window = sg.Window('PSG Demo & Project Browser',
layout,
finalize=True,
resizable=True,
use_default_focus=False,
right_click_menu=sg.MENU_RIGHT_CLICK_EDITME_VER_EXIT)
window.set_min_size(window.size)
window['-DEMO LIST-'].expand(True, True, True)
window[ML_KEY].expand(True, True, True)
window['-PANE-'].expand(True, True, True)
window.bind('<F1>', '-FOCUS FILTER-')
window.bind('<F2>', '-FOCUS FIND-')
window.bind('<F3>', '-FOCUS RE FIND-')
if not advanced_mode():
window['-FOLDER CHOOSE-'].update(visible=False)
window['-RE COL-'].update(visible=False)
window['-OPTIONS BOTTOM-'].update(visible=False)
# sg.cprint_set_output_destination(window, ML_KEY)
window.bring_to_front()
return window
def settings_window():
"""
Show the settings window.
This is where the folder paths and program paths are set.
Returns True if settings were changed
:return: True if settings were changed
:rtype: (bool)
"""
try:
global_editor = sg.pysimplegui_user_settings.get('-editor program-')
except:
global_editor = ''
try:
global_explorer = sg.pysimplegui_user_settings.get(
'-explorer program-')
except:
global_explorer = ''
try: # in case running with old version of PySimpleGUI that doesn't have a global PSG settings path
global_theme = sg.theme_global()
except:
global_theme = ''
layout = [
[sg.T('Program Settings', font='DEFAULT 25')],
[sg.T('Path to Tree', font='_ 16')],
[
sg.Combo(sorted(sg.user_settings_get_entry('-folder names-', [])),
default_value=sg.user_settings_get_entry(
'-demos folder-', get_demo_path()),
size=(50, 1),
key='-FOLDERNAME-'),
sg.FolderBrowse('Folder Browse', target='-FOLDERNAME-'),
sg.B('Clear History')
],
[sg.T('Editor Program', font='_ 16')],
[sg.T('Leave blank to use global default'),
sg.T(global_editor)],
[
sg.In(sg.user_settings_get_entry('-editor program-', ''),
k='-EDITOR PROGRAM-'),
sg.FileBrowse()
],
[sg.T('File Explorer Program', font='_ 16')],
[sg.T('Leave blank to use global default'),
sg.T(global_explorer)],
[
sg.In(sg.user_settings_get_entry('-explorer program-'),
k='-EXPLORER PROGRAM-'),
sg.FileBrowse()
],
[sg.T('Theme', font='_ 16')],
[sg.T('Leave blank to use global default'),
sg.T(global_theme)],
[
sg.Combo([''] + sg.theme_list(),
sg.user_settings_get_entry('-theme-', ''),
readonly=True,
k='-THEME-')
],
[
sg.T('Double-click a File Will:'),
sg.R('Run',
2,
sg.user_settings_get_entry('-dclick runs-', False),
k='-DCLICK RUNS-'),
sg.R('Edit',
2,
sg.user_settings_get_entry('-dclick edits-', False),
k='-DCLICK EDITS-'),
sg.R('Nothing',
2,
sg.user_settings_get_entry('-dclick none-', False),
k='-DCLICK NONE-')
],
[
sg.CB('Use Advanced Interface',
default=advanced_mode(),
k='-ADVANCED MODE-')
],
[sg.B('Ok', bind_return_key=True),
sg.B('Cancel')],
]
window = sg.Window('Settings', layout)
settings_changed = False
while True:
event, values = window.read()
if event in ('Cancel', sg.WIN_CLOSED):
break
if event == 'Ok':
sg.user_settings_set_entry('-demos folder-',
values['-FOLDERNAME-'])
sg.user_settings_set_entry('-editor program-',
values['-EDITOR PROGRAM-'])
sg.user_settings_set_entry('-theme-', values['-THEME-'])
sg.user_settings_set_entry(
'-folder names-',
list(
set(
sg.user_settings_get_entry('-folder names-', []) + [
values['-FOLDERNAME-'],
])))
sg.user_settings_set_entry('-explorer program-',
values['-EXPLORER PROGRAM-'])
sg.user_settings_set_entry('-advanced mode-',
values['-ADVANCED MODE-'])
sg.user_settings_set_entry('-dclick runs-',
values['-DCLICK RUNS-'])
sg.user_settings_set_entry('-dclick edits-',
values['-DCLICK EDITS-'])
sg.user_settings_set_entry('-dclick nothing-',
values['-DCLICK NONE-'])
settings_changed = True
break
elif event == 'Clear History':
sg.user_settings_set_entry('-folder names-', [])
sg.user_settings_set_entry('-last filename-', '')
window['-FOLDERNAME-'].update(values=[], value='')
window.close()
return settings_changed
def main():
## defines a layout for the GUI
layout = [
[sg.Image(data = logo, pad = (25, 0))],
[sg.Frame(layout = [
[sg.Text('Your results will be saved here')],
[sg.Text('Output folder'), sg.InputText(size = (40, 1), do_not_clear = True, key = 'output_folder'), sg.FolderBrowse()]],
title = 'Select an output folder')],
[sg.Frame(layout = [
[sg.Text('Username'), sg.InputText(userdata['username'], size = (25, 1), do_not_clear = True, key = 'username'),
sg.Text('Password'), sg.InputText(userdata['password'], size = (25, 1), do_not_clear = True, password_char = '*', key = 'password'),
sg.CB('Remember me', key = 'rem_pw', tooltip = 'This will save your userdata\non your computer without encryption!'),
sg.Button('Login', key = 'login_check')]],
title = 'User data')],
[sg.Frame(layout = [
[sg.Text('Select a database'), sg.Radio('COI', 'database', key = 'coi', default = True),
sg.Radio('ITS', 'database', key = 'its'), sg.Radio('rbcL & matK', 'database', key = 'rbcl'),
sg.Spin([i for i in range(1, 101)], initial_value = 100, size = (3, 1), key = 'batch_size'), sg.Text('Batch size')],
[sg.Text('Select a fasta file'), sg.InputText(size = (40, 1), do_not_clear = True, key = 'fasta_path'), sg.FileBrowse(), sg.Button('Run', key = 'id_eng', button_color = ('white', 'red'))]],
title = 'BOLD identification engine')],
[sg.Frame(layout = [
[sg.Text('Select a BOLDResults file'), sg.InputText(size = (40, 1), do_not_clear = True, key = 'resultpath'), sg.FileBrowse(), sg.Button('Run', key = 'add_data', button_color = ('white', 'red'))]],
title = 'Search for additional data')],
[sg.Frame(layout = [
[sg.Text('Select a method to determine the top hit (BOLDigger method requires additional data)')],
[sg.Radio('Use first hit', 'sort_method', key = 'firsthit', default = True), sg.Radio('JAMP Pipeline', 'sort_method', key = 'jamp'), sg.Radio('BOLDigger', 'sort_method', key = 'digger'), sg.Button('Run', key = 'tophit', button_color = ('white', 'red'))]],
title = 'Add a list of top hits')],
[sg.Button('Exit'), sg.Text('version: {}'.format(version)), sg.Button(image_data = github, key = 'github', pad = ((640, 0), 0))] #
]
window = sg.Window('BOLDigger', layout)
## check for update once on startup
update_check = True
## main loop
while True:
event, values = window.read(timeout = 100)
## check version on startup
if version != most_recent_version and update_check:
update_check = False
sg.popup('A new version of BOLDigger is available.\nPlease close the application and update.', title = 'Update')
if event == None or event == 'Exit':
break
if event == 'login_check':
session = login.login(values['username'], values['password'], certs, values['rem_pw'])
## search engine for coi
if event == 'id_eng' and values['coi']:
if values['fasta_path'] == '' or values['output_folder'] == '':
sg.popup('Please select input file and output folder.')
elif 'session' in locals():
window.Hide()
boldblast_coi.main(session, values['fasta_path'], values['output_folder'], values['batch_size'])
window.UnHide()
else:
sg.popup('Please log in first.')
## search engine for its
if event == 'id_eng' and values['its']:
if values['fasta_path'] == '' or values['output_folder'] == '':
sg.popup('Please select input file and output folder.')
elif 'session' in locals():
window.Hide()
boldblast_its.main(session, values['fasta_path'], values['output_folder'], values['batch_size'])
window.UnHide()
else:
sg.popup('Please log in first.')
## search engine for rbcl
if event == 'id_eng' and values['rbcl']:
if values['fasta_path'] == '' or values['output_folder'] == '':
sg.popup('Please select input file and output folder.')
elif 'session' in locals():
window.hide()
boldblast_rbcl.main(session, values['fasta_path'], values['output_folder'], values['batch_size'])
window.UnHide()
else:
sg.popup('Please log in first.')
## additional data code
if event == 'add_data' and values['resultpath'] == '':
sg.popup('Please select a resultfile first.')
if event == 'add_data' and values['resultpath'] != '':
window.Hide()
additional_data.main(values['resultpath'])
window.UnHide()
## addint top hits code
if event == 'tophit':
if values['resultpath'] == '':
sg.popup('Please select a resultfile first.')
elif values['firsthit']:
window.Hide()
first_hit.main(values['resultpath'])
window.UnHide()
elif values['jamp']:
window.Hide()
jamp_hit.main(values['resultpath'])
window.UnHide()
elif values['digger']:
window.Hide()
digger_sort.main(values['resultpath'])
window.UnHide()
if event == 'github':
webbrowser.open('https://github.com/DominikBuchner/BOLDigger')
window.Close()
#!/usr/bin/env python
import PySimpleGUI as sg
'''
App that shows "how fonts work in PySimpleGUI".
'''
layout = [[sg.Text('This is my sample text', size=(20, 1), key='-text-')],
[
sg.CB('Bold', key='-bold-', change_submits=True),
sg.CB('Italics', key='-italics-', change_submits=True),
sg.CB('Underline', key='-underline-', change_submits=True)
],
[
sg.Slider((6, 50),
default_value=12,
size=(14, 20),
orientation='h',
key='-slider-',
change_submits=True),
sg.Text('Font size')
],
[
sg.Text('Font string = '),
sg.Text('', size=(25, 1), key='-fontstring-')
], [sg.Button('Exit')]]
window = sg.Window('Font string builder', layout)
text_elem = window['-text-']
while True: # Event Loop
event, values = window.read()
