def window_layout():
""" Layout for the GUI window. """
layout = [[
sg.Text(
'Please browse to the path of the vocab.db file on your Kindle:')
], [sg.Input(key='database_field'),
sg.FileBrowse()],
[sg.Button('Show list of books in the Kindle'),
sg.Cancel()],
[
sg.Text(
'Error: please select the file vocab.db in your Kindle.',
visible=False,
key='database_error_message',
text_color='red')
], [sg.DropDown(values='', key='selected_book', size=(60, 6))],
[sg.Button(button_text='Generate the CSV file'),
sg.Exit()],
[
sg.Text('The CSV file has been generated successfully.',
visible=False,
key='file_generated_success',
text_color='green')
],
[
sg.Text('Whoops, that didn\'t work, please try again.',
visible=False,
key='file_generated_error',
text_color='green')
]]
return layout
def __init__(self, default_name=""):
default_name = path.splitext(default_name)[
0] # remove possible extension
defaults = [""] * 4
if default_name.endswith(TAG_BILINGUAL):
defaults[3] = BILINGUAL
default_name = default_name[:-1 * len(TAG_BILINGUAL)]
elif default_name.endswith(TAG_L1):
defaults[3] = consts.LANGUAGE1
default_name = default_name[:-1 * len(TAG_L1)]
elif default_name.endswith(TAG_L2):
defaults[3] = consts.LANGUAGE2
default_name = default_name[:-1 * len(TAG_L2)]
else:
defaults[3] = ""
for c, txt in enumerate(default_name.split(SEP, maxsplit=2)):
if c == 2: # cast number
try:
defaults[c] = str(int(txt))
except:
defaults[c - 1] += SEP + txt
else:
defaults[c] = txt
if len(defaults[1]) == 0 and len(defaults[0]) > 0:
defaults[1], defaults[0] = defaults[0], defaults[1]
self.txt_name1 = sg.Text("", size=(43, 1), key="txt_name1")
self.txt_name2 = sg.Text("", size=(43, 1), key="txt_name2")
fr_names = sg.Frame("", [[sg.Text("a:", size=(2, 1)), self.txt_name1],
[sg.Text("b:", size=(2, 1)), self.txt_name2]],
border_width=0)
self.fln0 = sg.InputText(default_text=defaults[0],
size=(5, 1),
key="fln0",
enable_events=True)
self.fln1 = sg.InputText(default_text=defaults[1],
size=(25, 1),
key="fln1",
enable_events=True)
self.fln2 = sg.InputText(default_text=str(defaults[2]),
size=(4, 1),
key="fln2",
enable_events=True)
self.fln3 = sg.DropDown(
default_value=defaults[3],
values=[consts.LANGUAGE1, consts.LANGUAGE2, BILINGUAL],
key="fln3",
enable_events=True)
self.frame = sg.Frame("Item Name(s)", [[
labeled_frame([self.fln0, sg.Text(SEP)], "Uni"),
labeled_frame([self.fln1, sg.Text(SEP)], "Topic"),
labeled_frame([self.fln2, sg.Text(SEP)], "Counter"),
labeled_frame(self.fln3, "Language")
], [fr_names]])
def gui():
defaults = psg.UserSettings()
close_program, client, repositories = get_aspace_log(defaults)
if close_program is True:
sys.exit()
main_layout = [[psg.Text("Choose your repository:", font=("Roboto", 12))],
[
psg.DropDown(
[repo for repo in repositories.keys()],
readonly=True,
default_value=defaults["repo_default"],
key="_REPO_SELECT_",
),
psg.Button(" SAVE ", key="_SAVE_REPO_")
],
[
psg.FileBrowse(
' Select Digital Objects File ',
file_types=(("Excel Files", "*.xlsx"), ),
),
psg.InputText(default_text=defaults['_DO_FILE_'],
key='_DO_FILE_')
],
[
psg.FileBrowse(
' Select Template ',
file_types=(("Excel Files", "*.xlsx"), ),
),
psg.InputText(default_text=defaults['_DOTEMP_FILE_'],
key='_DOTEMP_FILE_')
],
[psg.Button(' START ', key='_WRITE_DOS_', disabled=False)],
[psg.Output(size=(80, 18), key="_output_")]]
window = psg.Window('Write Digital Objects to Template',
layout=main_layout)
while True:
event, values = window.read()
if event == psg.WINDOW_CLOSED or event == 'Exit':
break
if event == '_WRITE_DOS_':
if not values['_DO_FILE_']:
psg.popup('Please select a digital objects file')
elif not values['_DOTEMP_FILE_']:
psg.popup('Please select a digital object template')
else:
defaults['_DO_FILE_'] = values['_DO_FILE_']
defaults['_DOTEMP_FILE_'] = values['_DOTEMP_FILE_']
write_digobjs(values['_DO_FILE_'], values['_DOTEMP_FILE_'],
client, repositories[values["_REPO_SELECT_"]],
window)
if event == "_SAVE_REPO_":
defaults["repo_default"] = values["_REPO_SELECT_"]
def enter_data():
known_users = pd.read_sql_query('SELECT * FROM known_users', conn)
movies = pd.read_sql_query('SELECT * FROM movies', conn)
names = movies['title'].tolist()
layout_ED = [[
sg.Text('What is your user name?', font=fonte),
sg.DropDown(values=known_users['username'].tolist(),
font=fonte,
key='chosen_user')
],
[
sg.Text('What film do you want to rate?', font=fonte),
sg.Input(do_not_clear=True,
size=(20, 1),
enable_events=True,
key='_INPUT_',
font=fonte),
sg.Listbox(values=names,
font=fonte,
enable_events=True,
key='_LIST_',
size=(40, 12))
], [sg.Button('Chrome', font=fonte),
sg.Cancel(font=fonte)]]
window = sg.Window('Get movie name', layout=layout_ED)
# Event Loop
while True:
event, values = window.Read()
if event is None or event == 'Cancel': # always check for closed window
window.Close()
break
if values['_INPUT_'] != '': # if a keystroke entered in search field
search = values['_INPUT_']
new_values = [x for x in names if search in x] # do the filtering
window.Element('_LIST_').Update(
new_values) # display in the listbox
else:
window.Element('_LIST_').Update(
names) # display original unfiltered list
if event == '_LIST_' and len(
values['_LIST_']): # if a list item is chosen
window.Close()
movieId = movies.loc[movies['title'] == values['_LIST_'][0],
'movieId']
userId = known_users.loc[known_users['username'] ==
values['chosen_user'], 'userId']
get_user_avaliations(values['_LIST_'][0],
movieId.tolist()[0],
userId.tolist()[0])
def generate_mt_layout(md):
col1 = [[sg.Text('mGroup')]]
col2 = [[sg.Text('Control Register')]]
col3 = [[sg.Text('Nibble')]]
a = [f'0x{el:02X}' for el in range(256)]
for k in md.keys():
tt = f'Nibble used to control mGroup {k[1]}.\n"U" => [7:4]\n"L" => [3:0]'
col1 += [[sg.Text(f'{k[1]}:')]]
col2 += [[
sg.DropDown(a,
default_value=md[k]['Reg'],
key=f'-{k[1]}R-',
size=(6, 1))
]]
col3 += [[
sg.DropDown(['U', 'L'],
default_value=md[k]['U/L'],
tooltip=tt,
key=f'-{k[1]}N-',
size=(4, 1))
]]
frame_layout = [[
sg.Column(col1, element_justification='right'),
sg.Column(col2, element_justification='center'),
sg.Column(col3, element_justification='center')
]]
layout = [[sg.Frame('', layout=frame_layout)],
[
sg.Stretch(),
sg.Ok(size=(10, 1)),
sg.Cancel(size=(10, 1)),
sg.Stretch()
]]
return layout
def __init__(self, default_name=""):
default_name = path.splitext(default_name)[0] # remove possible extension
defaults = [""] * 3
if default_name.endswith(TAG_BILINGUAL):
defaults[-1] = "Bilingual"
default_name = default_name[:-1*len(TAG_BILINGUAL)]
elif default_name.endswith(TAG_L1):
defaults[-1] = "Dutch"
default_name = default_name[:-1*len(TAG_L1)]
elif default_name.endswith(TAG_L2):
defaults[-1] = "English"
default_name = default_name[:-1*len(TAG_L2)]
else:
defaults[-1] = ""
for c, txt in enumerate(default_name.split(SEP, maxsplit=2)):
if c == len(defaults)-2: # cast number
try:
defaults[c] = str(int(txt))
except:
defaults[c-1] += SEP + txt
else:
defaults[c] = txt
self.txt_name1 = sg.Text("", size=(43, 1), key="txt_name1")
self.txt_name2 = sg.Text("", size=(43, 1), key="txt_name2")
self.fr_names = sg.Frame("", [[sg.Text("a:", size=(2,1)),
self.txt_name1],
[sg.Text("b:" , size=(2,1)),
self.txt_name2]],
border_width=0)
self.fln = [sg.InputText(default_text=defaults[0], size=(25,1),
enable_events=True)] # could have potentiall
# multiple parts
self.fln_cnt = sg.InputText(default_text=str(defaults[-1]), size=(4, 1),
enable_events=True)
self.fln_lang = sg.DropDown(default_value=defaults[-1],
values=["Dutch", "English", "Bilingual"],
enable_events=True)
self.frame = sg.Frame("Item Name(s)",[
[top_label([self.fln[0], sg.Text(SEP)], label="Topic"),
top_label([self.fln_cnt, sg.Text(SEP)], label="Counter"),
top_label(self.fln_lang, label="Language")],
[self.fr_names]
])
def _generate_tracks_and_layout(num_tracks, measures_per_track, meter):
note_config, scale = _get_note_config_and_scale(meter)
for track_idx in range(num_tracks):
track = MidiTrack(meter=meter, channel=track_idx, instrument=INSTRUMENT)
TRACKS.append(track)
CHANNELS.append([])
LAYOUT.append([])
layout_measures_row = []
mingus_keys = Chord.get_mingus_chord_for_harmonic_chord(key=KEY_PITCH, harmonic_chord=HarmonicChord.MajorTriad)
mingus_key_to_enum_mapping = Scale.get_mingus_key_to_key_enum_mapping(KEY)
chord_label = \
f'{KEY_PITCH.name}.{HARMONIC_CHORD.name}:.{"-".join(mingus_key_to_enum_mapping[mingus_key].name for mingus_key in mingus_keys)}'
chord_pitches = '_'.join(str(pitch) for pitch in
get_chord_pitches(mingus_keys=mingus_keys,
mingus_key_to_key_enum_mapping=mingus_key_to_enum_mapping,
pitch_for_key=pitch_for_key,
octave=OCTAVE))
for measure_idx in range(measures_per_track):
measure = Measure(meter=meter, num_notes=meter.beats_per_measure, mn=note_config)
track.append(measure)
layout_notes = []
for k in range(meter.beats_per_measure):
# Initialize each note to the params of the root note in the Scale
set_attr_vals_from_dict(measure[k], as_dict(scale[0]))
# PySimpleGUI refers to UI objects by "key" and returns this key when events are trapped on the UI.
# Prepend key with track num, this is the channel for the queue of messages from the UI to this track.
# Key each button to it's index in the flattened Messages list, key * 2 because the
# index into Messages is even indexes, because Messages are note_on/note_off pairs.
# NOTE: 'key' is overloaded and here means unique id referring to PySimpleGUI object.
# key must be unique. For note on_off the value is unique on each iteration so don't need key
event_id = f'{track_idx}_{2 * ((measure_idx * meter.beats_per_measure) + k)}'
start_key = f'note_on_off|{event_id}|{event_id}'
chord_key = f'chord|{event_id}|{str(chord_pitches)}'
note_checkbox = sg.Checkbox(str (k + 1), default=False, enable_events=True, key=start_key)
layout_notes.append(note_checkbox)
NOTE_ELEMENTS[track_idx].append(note_checkbox)
# chord_key needs a unique key id and a value, because values (i.e. which chord a note is) can repeat
layout_notes.append(sg.DropDown(values=str(chord_label), key=chord_key,
enable_events=True, size=(15, 15)))
layout_measures_row.append(sg.Frame(title=f'Measure {measure_idx + 1}', layout=[layout_notes]))
LAYOUT[track_idx].append(sg.Frame(title=f'Track {track_idx + 1}', layout=[layout_measures_row]))
def get_layout(self) -> List[List[Any]]:
"""
ReCreates the layout.
:return: The new layout.
"""
inputs = []
for i, s in enumerate(self.win_vars.input_sound):
# noinspection PyTypeChecker
inputs += [[sg.Text(F'Input {i}:'),
sg.DropDown(self.get_microphones(), key=F'-INPUT_DROPDOWN_#{i}-',
default_value=s.name, readonly=True,
enable_events=True)],
[sg.Text('Volume:'),
sg.Slider(range=VOLUME_RANGE, default_value=s.volume, key=F'-INPUT_SLIDER_#{i}-',
orientation='horizontal', enable_events=True),
sg.Button('Remove', key=F'-INPUT_REMOVE_#{i}-')]]
outputs = []
for i, s in enumerate(self.win_vars.output_sound):
# noinspection PyTypeChecker
outputs += [[sg.Text(F'Output {i}:'),
sg.DropDown(self.get_speakers(), key=F'-OUTPUT_DROPDOWN_#{i}-',
default_value=s.name, readonly=True,
enable_events=True)],
[sg.Text('Volume:'),
sg.Slider(range=VOLUME_RANGE, default_value=s.volume, key=F'-OUTPUT_SLIDER_#{i}-',
orientation='horizontal', enable_events=True),
sg.Button('Remove', key=F'-OUTPUT_REMOVE_#{i}-')]]
# noinspection PyTypeChecker
layout = inputs + [[sg.Button("Add Input", key='-INPUT_ADD-')]] \
+ outputs + [[sg.Button("Add Output", key='-OUTPUT_ADD-')],
[sg.Button("Update", key="-UPDATE-")]]
return layout
def createLayout(ports: list):
sg.theme('SystemDefault')
layout = [[
sg.DropDown(ports, size=(12, 1), key='COMPORT', enable_events=True),
sg.Radio('Steady',
group_id='CMD',
default=True,
key='CMD_STEADY',
enable_events=True),
sg.Radio('Blink', group_id='CMD', key='CMD_BLINK', enable_events=True),
sg.Radio('UseButton',
group_id='CMD',
default=False,
visible=False,
key='CMD_NO_RAD')
],
[
sg.Text('red '),
sg.Slider(range=(0, 255),
key='RED',
orientation='hor',
enable_events=True)
],
[
sg.Text('green'),
sg.Slider(range=(0, 255),
key='GREEN',
orientation='hor',
enable_events=True)
],
[
sg.Text('blue '),
sg.Slider(range=(0, 255),
key='BLUE',
orientation='hor',
enable_events=True)
],
[sg.Text('status: '),
sg.Text('', key='status', size=(50, 1))],
[
sg.Button('ALL ON', key='CMD_ALL_ON', enable_events=True),
sg.Button('ALL OFF', key='CMD_ALL_OFF', enable_events=True)
]]
window = sg.Window('Nucleo Color Selector', layout)
window.finalize()
return layout, window
def get_user_avaliations(name, movieId, userId):
# Check if such avaliation exists
A = c.execute('SELECT * FROM ratings WHERE userId = ? AND movieId = ?',
(userId, movieId)).fetchall()
conn.commit()
update_movie = 'No'
b_proceed = True
if len(A) > 0:
update_movie = sg.popup_yes_no(
'This user already rated this movie with ' + str(A[0][2]) +
' stars. Do you want to change this rating?',
font=fonte)
if update_movie == 'No':
b_proceed = False
if b_proceed:
layout_GUA = [
[sg.Text("How do you rate " + name + "?", font=fonte)],
[
sg.DropDown(
[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0],
font=fonte,
key='rating')
], [sg.Button('Rate', key=True),
sg.Button('Return', key=False)]
]
# Create window
window = sg.Window('Rate a movie', layout=layout_GUA)
button, values = window.Read()
window.Close()
if button:
rating = values['rating']
timestamp = time.time()
if update_movie == 'No':
ratings_entry([(float(userId), float(movieId), rating,
timestamp)])
else:
ratings_update([(rating, timestamp, float(userId),
float(movieId))])
def do_it(x, y, z):
con = cx_Oracle.connect('EOM/[email protected]/xe')
cur = con.cursor(scrollable=True)
sg.ChangeLookAndFeel('DarkBlue')
global old_class
global old_period_number
old_class = str(x + '/' + z)
old_period_number = int(y)
layout = [[sg.Text('Edit Classes - ' + x, size=(30, 2), justification='center', font=("Helvetica", 25))],
[sg.Text(' Course Code', size=(50, 1), justification='center', font=("Helvetica", 15))],
[sg.Input(x, size=(20, 2), pad=((215, 150), 10))],
[sg.Text(' Period Number', size=(50, 1), justification='center', font=("Helvetica", 15))],
[sg.Input(y, size=(20, 2), pad=((215, 150), 10))],
[sg.Text('Year', size=(50, 1), justification='center', font=("Helvetica", 15))],
[sg.DropDown((2016, 2017, 2018, 2019), size=(18, 2), pad=((214, 150), 10), default_value=int(z))],
[sg.ReadButton('Edit Course', key='edit_courses_button', size=(20, 2), pad=((205, 150), 10),
bind_return_key=True)]
]
window = sg.Window('Edit Courses', default_element_size=(40, 2)).Layout(layout)
while 'edit_courses_button':
event, values = window.Read()
if event is None or event == 'Exit':
break
cur.execute("UPDATE EOM_CLASS SET PERIOD_NUM = :v_period_num WHERE CLASS = :other_stuff", v_period_num=values[1],
other_stuff=old_class)
cur.execute("UPDATE EOM_CLASS SET CLASS = :v_class WHERE CLASS = :stuff", v_class=values[0] + '/' + values[2],
stuff=old_class)
con.commit()
break
window.Close()
key="pro",
enable_events=True,
default=True,
size=(6, 1)),
sg.Radio("Full Rate",
group_id="promo",
key="full",
enable_events=True)
],
[
sg.Text("Enter Corp", size=(15, 1)),
sg.InputText(key='corp', size=(8, 1))
],
[
sg.Text("Select Market", size=(15, 1)),
sg.DropDown(values=opt_markets, key='market', size=(6, 1))
],
[
sg.Text("Select Cluster", size=(15, 1)),
sg.DropDown(values=cluster_opt, key='cluster', size=(6, 1))
],
[
sg.Text("Enter FTAX", size=(15, 1)),
sg.InputText(key='ftax', visible=False, size=(8, 1))
],
[
sg.Text("Enter EID", size=(15, 1)),
sg.InputText(key='eid', visible=False, size=(8, 1))
],
[
sg.Text("Check Parameters", size=(15, 1)),
def start():
WINDOW_TITLE = 'Instagram Uploader Bot'
sg.theme('Dark') # Add a touch of color
# All the stuff inside your window.
accounts = [
account for account in open("accounts.txt", "r").read().split("\n")
if account
] # gets all accounts
if len(accounts) == 0:
sg.popup_error(
'No accounts found. Try running setup.py and then start.py again.')
quit()
layout = [
[
sg.Text('Enter the username of the account you want to scrape:'),
sg.InputText(key='-SCRAPE_USERNAME-', size=(41, 0))
],
[
sg.Text(
"Enter the timestamp of your last post (if nothing is entered, it will be taken from the 'last_timestamp.txt' file):"
)
],
[
sg.InputText(key='-TIMESTAMP-', size=(11, 0)),
sg.Button('epochconverter.com')
],
[
sg.Text("Enter how many posts you want to posts from the user:"******"Select your account:"),
sg.DropDown(accounts, key='-ACCOUNT-', default_value=accounts[0]),
sg.Button('Start'),
sg.Button('Cancel')
]
]
# Create the Window
window = sg.Window(WINDOW_TITLE, layout)
# Event Loop to process "events" and get the "values" of the inputs
while True:
event, values = window.read()
if event == 'epochconverter.com':
os.startfile('https://www.epochconverter.com/')
if event == 'Start':
account = values['-ACCOUNT-']
scrape_username = values["-SCRAPE_USERNAME-"]
while not scrape_username:
if scrape_username is None:
quit()
scrape_username = sg.popup_get_text(
"Username cannot be blank.")
# checks
with open(os.path.join(account, "scraped_accounts.txt"),
"a+") as f:
f.seek(0)
scraped_accounts = f.read().split("\n")
if scrape_username in scraped_accounts:
is_continue = sg.popup_yes_no(
"Warning",
"You have already scraped posts from that user. Are you sure you want to scrape them again?"
)
while not is_continue:
if is_continue is None:
quit()
is_continue = sg.popup_yes_no(
"Warning",
"You have already scraped posts from that user. Are you sure you want to scrape them again?"
)
input_timestamp = values["-TIMESTAMP-"]
num_posts = values["-NUM_POSTS-"]
regex = r"\b([1-9]|[1-8][0-9]|9[0-9]|100)\b"
while not re.search(regex, num_posts):
if num_posts is None:
quit()
num_posts = sg.popup_get_text(
"Input must be a number between 1-100.")
num_posts = int(num_posts)
main(scrape_username, input_timestamp, num_posts, account)
if event == sg.WIN_CLOSED or event == 'Cancel': # if user closes window or clicks cancel
break
window.close()
def _open_choose_trial(curr_trial, all_trials):
"""
Open the 'choose trial number' window
"""
trial_nums = [t.trial_id for t in all_trials]
trial_desc = [
"{}: {}{}".format(t.trial_id, t.stimulus,
" (already encoded)" if t.processed else "")
for t in all_trials
]
trial_desc_to_num = {d: n for d, n in zip(trial_desc, trial_nums)}
curr_trial_ind = all_trials.index(curr_trial)
show_popup = True
warning = ''
while show_popup:
layout = [
[sg.Text(warning, text_color='red', font=('Arial', 18))],
[
sg.Text('Go to trial number: '),
sg.DropDown(trial_desc,
default_value=trial_desc[curr_trial_ind],
readonly=True)
],
[sg.Button('OK'), sg.Button('Cancel')],
]
window = sg.Window('Choose trial', layout)
event = None
apply = False
values = ()
while event is None:
event, values = window.Read()
apply = event == 'OK'
window.Close()
if apply:
try:
trial_id = trial_desc_to_num[values[0]]
except ValueError:
warning = 'Invalid trial: please write a whole number'
continue
if not (min(trial_nums) <= trial_id <= max(trial_nums)):
warning = 'Invalid trial number (choose a number between {:} and {:}'.format(
min(trial_nums), max(trial_nums))
continue
if trial_id not in trial_nums:
warning = 'A trial with this number does not exist'
continue
matching = [t for t in all_trials if t.trial_id == trial_id]
return matching[0]
else:
return curr_trial
outputThing.Update(''.join(lines))
win32clipboard.CloseClipboard()
print("Stream slept for {}".format(streamTime))
self.active_streaming = False
pass
pass
def streaming(self):
ok = "ok"
_thread.start_new_thread(self.stream_threaddd, ("ok", "okk"))
hostList = ["I'm Outside", "I'm Inside"]
mw = [[
sg.DropDown(hostList,
default_value="I'm Outside",
size=(24, 1),
key="host"),
sg.InputText("Enter Your Username Dude(et)", size=(28, 1), key="user"),
sg.Text("pw:"),
sg.InputText("okokok", size=(26, 1), password_char="^", key="pass")
], [sg.Multiline(size=(87, 21), key="ml")],
[
sg.Button("Connect", key="open"),
sg.Button("Disconnect", key="close"),
sg.Text("", size=(18, 1)),
sg.Button("Streaming Clipboard: OFF",
button_color=("White", "Red"),
key="auto"),
sg.Button("Copy Down", key="pull"),
sg.Button("Paste Up", key="push")
]]
import PySimpleGUI as sg
import pdftotext
from gtts import gTTS
langs = ["English", "French "]
window = sg.Window(
'Get filename example',
[[sg.Text('Filename')],
[
sg.Input(),
sg.FileBrowse('Chopse a pdf file ',
file_types=(("PDF Files", "*.pdf"), ))
], [sg.Text('Language :'),
sg.DropDown(langs, default_value=langs[0])], [sg.OK(),
sg.Cancel()]])
event, values = window.Read()
window.close()
pdf = None
try:
with open(values[0], "rb") as f:
pdf = pdftotext.PDF(f)
except pdftotext.Error as e:
print(e)
except TypeError as e:
print("Didn't choose a file!", '\n', 'closed !')
except Exception as e:
print(e)
if pdf:
lang_option = values[1][:2].lower()
string_of_text = ''.join(e for e in pdf)
def make_window_read_data(training, models_list=None):
"""
Creates window with functionality of reading data for model
:param training: defines if window should be used for selection of training or testing data
:type training: bool
:param models_list: list of all created models' names
:type models_list: list[str]
:return: window reading data for model from file
:rtype: PySimpleGUI.PySimpleGUI.Window
"""
if training:
data_type = 'training'
else:
data_type = 'test'
# layout of the left column with directories and files
files_column = [
[
sg.Button("Back", focus=False, enable_events=True, key="-BACK-")
],
[
sg.Text(f"Select directory containing {data_type} data for the model")
],
[
sg.Text("Folder"),
sg.In(size=(25, 1), enable_events=True, key="-FOLDER-"),
sg.FolderBrowse(),
],
[
sg.Listbox(
values=[], enable_events=True, size=(40, 20), key="-FILE LIST-",
)
]
]
pre_bottom_row = list()
bottom_row = list()
if training:
pre_bottom_row.append(sg.Text("Model's name:"))
pre_bottom_row.append(sg.In(size=(15, 1), enable_events=False, key="-MODEL NAME-"))
bottom_row.append(sg.Button("Select this directory", focus=True, enable_events=True, key="-SELECT BUTTON-"))
bottom_row.append(sg.Checkbox("Shape from file",
tooltip="Use shape model information from predefined file if available",
key="-MARKED POINTS-"))
else:
files_column.append([
sg.T(' ' * 16),
sg.Text("Model")
])
pre_bottom_row.append(sg.DropDown(models_list, tooltip="Select model to show", size=(25, 10),
enable_events=True, key="-MODEL NAME-"))
bottom_row.append(sg.Button("Select this image", focus=True, enable_events=True, key="-SELECT BUTTON-"))
files_column.append(pre_bottom_row)
files_column.append(bottom_row)
# layout of the right column with image overview
image_column = [
[sg.Text("Image overview")],
[sg.Text(size=(40, 1), key="-IMG NAME-")],
[sg.Image(filename="", key="-IMAGE-")],
]
# layout of whole window
layout = [
[
sg.Column(files_column),
sg.VSeparator(),
sg.Column(image_column),
]
]
return sg.Window(f"Choose {data_type} data", layout, element_justification="c", finalize=True)
enter_submits=True,
auto_size_text=True,
key="key1",
default_text=results,
background_color="#FFF"),
sg.Button("Apply")],
[sg.Text("Save Directory", size=(14, 1), pad=(0, 5)),
sg.InputText(config.get("mainConfig", "saveDirectory"),background_color="#FFF", size=(53,1)),
sg.FolderBrowse(button_text="Select")],
]
config3 = [
[sg.T("Chrome Driver Options",size=(500, 1),auto_size_text=True,justification='center', font=("Arial", 10), background_color="#888", text_color="#FFF", pad=(5, 5))],
[sg.T("Browser Agents", size=(13,1))],
[sg.DropDown(brlist,default_value=config.get("GoogleConfig","bragent"),pad=(5,5), size=(90,3))],
[sg.Checkbox(pad=(5,5),text="Extensions",tooltip="Enable/Disable browser extensions ",default=config.getboolean("GoogleConfig", "extensions"))],
[sg.Checkbox(pad=(5,5),text="Window", tooltip="Show browser window", default=config.getboolean("GoogleConfig", "extensions"))],
[sg.Checkbox(pad=(5,5),text="GPU",tooltip="Add/Remove browser GPU rendering", default=config.getboolean("GoogleConfig", "extensions"))],
[sg.Checkbox(pad=(5,5),text="Use Profile", tooltip=("Trying to use saved login credentials"),default=config.getboolean("GoogleConfig", "extensions"))],
[sg.Checkbox(pad=(5,5),text="Sandbox",tooltip="Using Sandbox",default=config.getboolean("GoogleConfig", "extensions"))]
]
config4 = [
[sg.T("Delay Settings",size=(500, 1),auto_size_text=True,justification='center', font=("Arial", 10), background_color="#888", text_color="#FFF", pad=(5, 5))],
[sg.T(pad=(5,5),text="Manual Login Delay",size=(20, 1)),
sg.InputText(size=(5,1), default_text=(config.getint("Timings", "logintime")))],
[sg.T(pad=(5,5),text="Get Video List Delay",size=(20, 1)),
sg.InputText(size=(5,1), default_text=(config.getint("Timings", "loadingallvideos")))],
[sg.T(pad=(5,5),text="Get Course Name Delay",size=(20, 1)),
sg.InputText(size=(5,1), default_text=(config.getint("Timings", "extractcoursename"))),
layout = [
[
sg.Text("IG Upload Helper",
font=("Ariel 16 bold"),
justification='center',
size=(x, 1))
], [sg.Text("")],
[sg.Text("First Time (for each account)", font=("Ariel 14 bold"))],
[
sg.Button("Setup", size=(8, 2)),
],
[
sg.Text("Select account:", visible=accounts_visible),
sg.DropDown(accounts,
key='-SELECT_ACCOUNT-',
default_value=default_account,
visible=accounts_visible), barrier_visible,
sg.Text("Setup files:"),
sg.Button("Descriptions"),
sg.Button("Hashtags"),
sg.Button("Caption")
],
[
sg.Text(
"-------------------------------------------------------------------------------------------------------------------------------------------------------"
)
], [sg.Text("Run Bot", font=("Ariel 14 bold"))],
[sg.Text("Scrape and upload", font="Ariel 11 bold")],
[
sg.Text('Enter the username of the account you want to scrape:'),
sg.InputText(key='-SCRAPE_USERNAME-', size=(41, 0))
def get_mtrigs_result(df):
"""
Generate mtrigs dictionary from the test result df.
Parameters
----------
df : DataFrame
DataFrame containing the test results
Returns
-------
md : dict
Dictionary containing the mappable trigger information.
"""
def get_md(ml, mi):
"""
Get dictionary containing the mappable trigger information from user input.
Parameters
----------
ml : [[str,str]]
List with register, nibble pairs.
mi : dict
Dictionary for user input mGroup names.
Returns
-------
md : dict
Dictionary containing the mappable trigger information.
"""
md = {}
for i in range(len(ml)):
if ml[i][0] in md.keys():
md[ml[i][0]][ml[i][1]] = mi[f'-{i}-']
else:
md[ml[i][0]] = {ml[i][1]: mi[f'-{i}-']}
return md
mtrigs = df.query('Type == "MASKED_WRITE"')[['Address','Mask']].values.astype(int).tolist()
mtrigs = [(el[0], el[1]) for el in mtrigs]
mtrigs = list(set(mtrigs))
mtrigs = [[f'0x{el[0]:02X}', f'0x{el[1]:02X}'] for el in mtrigs]
mtrigs.sort()
col1_layout = [[sg.Text('Register')]]
col2_layout = [[sg.Text('Nibble')]]
col3_layout = [[sg.Text('mGroup')]]
mnt = {'0xF0': '[3:0]', '0x0F': '[7:4]'}
for i in range(len(mtrigs)):
col1_layout += [[sg.Text(f'Reg{mtrigs[i][0]}')]]
col2_layout += [[sg.Text(f'{mnt[mtrigs[i][1]]}')]]
col3_layout += [[sg.DropDown([el for el in uc], size=(6, 1), key=f'-{i}-')]]
layout = [[sg.Column(col1_layout), sg.Column(col2_layout), sg.Column(col3_layout)],
[sg.Stretch(), sg.Ok(size=(10, 1)), sg.Cancel(size=(10, 1)), sg.Stretch()]]
mt_window = sg.Window('mTrig Setup', layout=layout)
while True:
mt_evts, mt_vals = mt_window.read(timeout=100)
if mt_evts is None or mt_evts == 'Cancel':
mt_window.close()
return None
if mt_evts == 'Ok' and all(mt_vals.values()):
md = get_md(mtrigs, mt_vals)
mt_window.close()
break
return md
[sg.Text('Edit actual entries', font=("Helvetica", 25))],
[
sg.Text(
'Select PLC IP address to get configured data aliases, then choose one to get all parameters connected with it'
)
]
]
plc_list = []
alias_list = []
plc_list = get_actual_plcs()
column1 = [[sg.Text('PLC IP address\t\t\tData alias')],
[
sg.DropDown(values=tuple(plc_list),
size=(15, 1),
key='PLC',
tooltip='select PLC to find information',
readonly=True,
default_value=plc_list[0]),
sg.Button('Find aliases'),
sg.DropDown(values=tuple(),
size=(15, 1),
key='ALIAS',
tooltip='select alias to find information'),
sg.Button('Find data')
]]
# add row to enable editing row associated with the selected alias
data_row = [
sg.Drop(values=areas,
auto_size_text=True,
key='AREA_EDIT',
max_optim_len = max([len(string) for string in optimizer_list]) + 1
optimizer_parameter_dict = {optimizer:get_default_args(getattr(torch.optim,optimizer)) for optimizer in optimizer_list }
initial_optim_params_list = list( optimizer_parameter_dict[optimizer_list[0]] )
init_params_dict = optimizer_parameter_dict[optimizer_list[0]]
max_optim_len = max([len(string) for string in optimizer_list])
layout = [
[sg.Text('GOOEY Neural Nets: Logistic Regression', size=(text_len, 1), justification='center', font=("Defau", 25), relief=sg.RELIEF_RIDGE)],
[sg.Frame(layout = [
[sg.Text('Datapoints:',size = (data_frame_text_len,1)), sg.Slider(default_value = 1000,range=(0, 100000), size=(60, 20), orientation='h', key='data_slider')],
[sg.Text('noise in data:',size = (data_frame_text_len,1)), sg.Slider(default_value = 0.5,range=(0, 100) , resolution = 0.1, size=(60, 20), orientation='h', key='noise_slider')],
[sg.Text('Number of clusters:',size = (data_frame_text_len,1)) , sg.DropDown(values = list(range(1,11)) , default_value = 2, size = (5,1),key='cluster_slider' ) ]
], relief = sg.RELIEF_SUNKEN , title = 'DATA' ) ],
[sg.Frame(layout = [
[sg.Text('Number of neurons in layer:',size = (model_frame_text_len,1) ),sg.Slider(default_value = 2, range=(1, 100), size=(60, 20), orientation='h', key='neuron_slider') ],
[sg.Text('Number of hidden layers:',size = (model_frame_text_len,1)),sg.Slider(default_value = 2,range=(1, 100), size=(60, 20), orientation='h', key='hidden_slider') ],
[sg.Text('Learning Rate:',size = (model_frame_text_len,1)) ,sg.Slider(default_value = 0.01,range=(0, 10),resolution=0.01, size=(60, 20), orientation='h', key='lr_slider') ],
[sg.Text('Epochs:',size = (model_frame_text_len,1)),sg.Slider(default_value = 1000,range=(0, 10000),resolution=1, size=(60, 20), orientation='h', key='epoch_slider') ],
[sg.Text('Optimizers:',size = (model_frame_text_len,1)),sg.DropDown(values = optimizer_list , default_value = optimizer_list[0],enable_events = True, key = 'optimizer',size = (max_optim_len,1))],
[sg.Text('Optimizer parameters:',size = (model_frame_text_len,1)), sg.DropDown(values = initial_optim_params_list, default_value = initial_optim_params_list[0], enable_events = True , key ='optimizer_params')],
[sg.Text('parameter value:',size = (model_frame_text_len,1)),sg.Input( init_params_dict[ initial_optim_params_list[0]],tooltip = 'Enter in format shown', key = 'param_value',size = (10,1)) , sg.Text(type(init_params_dict[ initial_optim_params_list[0]]),key='param_type' ) , sg.Button('Update',key = 'update') ,sg.Button('reset all',key = 'reset')]
def PopupDropDown(title, text, values):
window = sg.Window(title,
[[sg.Text(text)], [sg.DropDown(values, key='-DROP-')],
[sg.OK(), sg.Cancel()]])
event, values = window.read()
return None if event != 'OK' else values['-DROP-']
"{ODBC Driver 11 for SQL Server} - supports SQL Server 2005 through 2014\n" \
"{ODBC Driver 13 for SQL Server} - supports SQL Server 2005 through 2016\n" \
"{ODBC Driver 13.1 for SQL Server} - supports SQL Server 2008 through 2016\n" \
"{ODBC Driver 17 for SQL Server} - supports SQL Server 2008 through 2017"
sqlConnect = [
[
sg.Text("SQL Driver", size=(10, 1)),
sg.DropDown(enable_events=True,
readonly=True,
font=10,
default_value=config.get("sqlConfig", "sql_driver"),
size=(24, 1),
tooltip=sqlRefference,
pad=(0, 5),
values=[
"{SQL Server}", "{SQL Native Client}",
"{SQL Server Native Client 10.0}",
"{SQL Server Native Client 11.0}",
"{ODBC Driver 11 for SQL Server}",
"{ODBC Driver 13 for SQL Server}",
"{ODBC Driver 13.1 for SQL Server}",
"{ODBC Driver 17 for SQL Server}"
])
],
[
sg.Text("Instance", size=(10, 1), pad=(0, 5)),
sg.InputText(default_text=(config.get("sqlConfig", "SQL_SERVER"))),
],
[
sg.Text("Port", size=(10, 1), pad=(0, 5)),
sg.InputText(default_text=(config.get("sqlConfig", "SQL_PORT")))
def PopupDropDown(title, text, values):
window = sg.Window(title).Layout([[sg.Text(text)],
[sg.DropDown(values, key='_drop')],
[sg.OK(), sg.Cancel()]])
button, values = window.Read()
return None if button != 'OK' else values['_drop']
def _create_window_for_markup(screen_size, title, user_response):
commands_c = [
sg.Text('Trial-level: '),
sg.Button('(R)eset current trial', key='reset_trial'),
sg.Button('Split (T)rial', key='split_trial'),
sg.Text(' Stroke-level: '),
sg.Button('Split (S)troke', key='split_stroke'),
sg.Button('(D)elete stroke', key='delete_stroke'),
]
commands_s = [
sg.Text('Character-level: '),
sg.Button('Split (C)har', key='split_char'),
sg.Button('(M)erge chars', key='merge_chars'),
sg.Button('E(x)tend char', key='set_extending_chars'),
sg.Checkbox('Show extending chars',
key='show_extending',
enable_events=True,
default=app_config['show_extending']),
]
commands_nav = [
sg.Text('Navigation / decision: '),
sg.Button('(A)ccept as OK', key='accept'),
sg.Button('Err(o)r:', key='accept_error'),
sg.DropDown(app_config['error_codes'],
key='error_code',
enable_events=True,
readonly=True,
background_color='#FFFFFF'),
sg.Button('s(K)ip current trial', key='skip_trial'),
sg.Button('(P)revious trial', key='prev_trial'),
sg.Button('(G)o to specific trial', key='choose_trial'),
]
commands_resp = [
sg.Txt('User response:'),
sg.Input(default_text=user_response,
key='user_response',
readonly=True,
background_color='#CFCFCF'),
sg.Button('Update...', key='enter_response'),
]
commands_general = [
sg.Button('S(E)ttings', key='settings'),
sg.Button('(Q)uit WEncoder', key='quit'),
]
layout = [[
sg.Text(' ' * 200,
text_color='white',
key='instructions',
font=('Arial', 16))
],
[
sg.Graph(screen_size, (0, screen_size[1]),
(screen_size[0], 0),
background_color='Black',
key='graph',
enable_events=True)
], commands_c, commands_s, commands_nav, commands_resp,
commands_general]
label = tk.Label(text="Hello, Tkinter", fg="white", bg="yellow")
label.pack()
window = sg.Window(title,
layout,
return_keyboard_events=True,
resizable=True)
window.Finalize()
return window
def main_gui():
global status, stop_threads # pylint: disable=global-statement
# Variables
current_date = date.today()
current_date = current_date.strftime("%B %d %Y")
thread = None
sentence_file = ''
text_memory = ''
speaker_name = None
cuda_available = is_available()
gst_dict = {}
# preload style token dict with zeros
for index, _ in enumerate(range(10)):
gst_dict[str(index)] = float(0.0)
# set icon depending on distro
icon = PATH_GUI_ICON + '.ico' if _platform == 'Windows' else PATH_GUI_ICON + '.png'
# set the theme
#sg.theme('DarkTeal6')
sg.theme(
'CustomTheme'
) # Custom theme defined at the bottom of the script. This theme can be modified or replaced with default themes, see above.
# init default settings
radio_keys = {
'radioGL': 'GriffinLim',
'radioWR': 'WaveRNN',
'radioMG': 'MelGAN'
}
radio_image_keys = {
'radioGL': 'imgradioGL',
'radioWR': 'imgradioWR',
'radioMG': 'imgradioMG'
}
selected_color = ('white', '#273c75')
active_radio_button = 'radioGL'
loadingAnimation = sg.Image(filename=LOADING_GIF,
size=(10, 1),
visible=False,
key='loadingAnim',
background_color='white')
use_cuda = sg.Checkbox('Use CUDA?',
default=cuda_available,
font=('Arial', 11),
visible=cuda_available,
key='use_cuda')
cuda_color = 'green' if cuda_available else 'red'
cuda_text = '(CUDA Supported)' if cuda_available else '(CUDA Not Supported)'
generate_button_disabled = False
# get project folders and speaker_list if multispeaker model
project_folders = [
Path(folder) for folder in glob(str(Path(PATH_PROJECT, '*/')))
]
if project_folders:
CURRENT_PROJECT_PATH = str(project_folders[0])
project_folder_name = [str(folder.name) for folder in project_folders]
speakers_file_path = Path(CURRENT_PROJECT_PATH, "speakers.json")
if speakers_file_path.is_file():
with open(speakers_file_path, 'r') as json_file:
speaker_data = json.load(json_file)
speaker_list = [speaker for speaker, _ in speaker_data.items()]
else:
speaker_list = ['Default']
else:
CURRENT_PROJECT_PATH = ''
generate_button_disabled = True
project_folder_name = ['No Projects']
speaker_list = ['No Speaker']
print(f'[!] No model found in projects folder: {PATH_PROJECT}')
max_length_name = len(max(speaker_list, key=len)) + 2
# All the stuff inside your window.
layout = [
[sg.Text('Project Settings:', font=('Arial', 12, 'bold'))],
[
sg.Text(cuda_text,
text_color=cuda_color,
font=('Arial', 11, 'bold')), use_cuda
],
[
sg.Text('Project:',
pad=[5, 5],
size=(10, 1),
justification='left',
font=('Arial', 11),
key='lblProject'),
sg.DropDown(project_folder_name,
project_folder_name[0],
enable_events=True,
pad=[5, 5],
font=('Arial', 11),
key='dbProject')
],
[
sg.Text('Speaker:',
pad=[5, 5],
size=(10, 1),
justification='left',
font=('Arial', 11),
key='lblSpeaker'),
sg.DropDown(speaker_list,
speaker_list[0],
size=(max_length_name, 1),
pad=[5, 5],
font=('Arial', 11),
key='dbSpeaker'),
sg.Checkbox('Generate for all',
default=False,
font=('Arial', 11),
key='create_all')
],
[sg.Text('_' * 90)],
[sg.Text('Vocoder Settings:', font=('Arial', 12, 'bold'))],
[
sg.Image(data=CHECK_ICON, pad=(0, 5), key='imgradioGL'),
sg.Button('GriffinLim',
size=(12, 1),
pad=((0, 15), 5),
key='radioGL'),
sg.Image(data=UNCHECK_ICON, pad=(0, 5), key='imgradioWR'),
sg.Button('WaveRNN', size=(12, 1), pad=((0, 15), 5),
key='radioWR'),
sg.Image(data=UNCHECK_ICON, pad=(0, 5), key='imgradioMG'),
sg.Button('MelGAN', size=(12, 1), pad=((0, 15), 5), key='radioMG')
],
[sg.Text('_' * 90)],
[sg.Text('Emotion Settings: ', font=('Arial', 12, 'bold'))],
[
sg.Text('Emotion: ', size=(10, 1), font=('Arial', 11)),
sg.DropDown(['Normal', 'Angry', 'Dominant', 'Calm'],
'Normal',
font=('Arial', 11),
enable_events=True,
key='dbEmotion')
],
[
sg.Text('Speed of Speech: ',
pad=[5, 5],
size=(20, 1),
font=('Arial', 11),
key='token0'),
sg.Slider(range=(-20, 20),
default_value=0,
size=(30, 10),
orientation='horizontal',
font=('Arial', 8, 'bold'),
key='speedSlider')
],
[
sg.Text('Dominance of Speech: ',
pad=[5, 5],
size=(20, 1),
font=('Arial', 11),
key='token1and2'),
sg.Slider(range=(-20, 20),
default_value=0,
size=(30, 10),
orientation='horizontal',
font=('Arial', 8, 'bold'),
key='emotionSlider')
],
[
sg.Text('Tone of Speech: ',
pad=[5, 5],
size=(20, 1),
font=('Arial', 11),
key='token5'),
sg.Slider(range=(-20, 20),
default_value=0,
size=(30, 10),
orientation='horizontal',
font=('Arial', 8, 'bold'),
key='toneSlider')
],
[sg.Text('_' * 90)],
# [sg.Checkbox('Use file for speech generation', False, font=('Arial', 11, 'bold'), enable_events=True, key='cbLoadFile')],
[
sg.Text('Use file for speech generation',
font=('Arial', 11, 'bold'),
key='lblLoadFile'),
sg.Button('Browse', size=(8, 1), pad=(1, 5), key='btnFileBrowse'),
sg.Button(image_data=EXIT_ICON,
pad=(0, 5),
visible=False,
button_color=('black', '#ff5e5e'),
key='btnCloseFileLoad'),
],
[
sg.Multiline(
'Im Minental versammelt sich eine Armee des Bösen unter der Führung von Drachen! Wir müssen sie aufhalten, so lange wir noch können.',
size=(65, 6),
pad=[5, 5],
border_width=1,
font=('Arial', 12),
text_color=TEXT_COLOR,
background_color=TEXTINPUT_BACKGROUND,
key='textInput'),
sg.Button('Output\nFolder',
size=(5, 3),
enable_events=True,
key='btnOpenOutput')
],
[
sg.Button('Generate',
size=(12, 1),
disabled=generate_button_disabled,
key='btnGenerate'),
sg.Button('Exit', size=(8, 1), key='btnExit'), loadingAnimation
]
]
# Create the Window
window = sg.Window('Mozilla TTS (Generate Speech From Text)',
icon=icon,
layout=layout,
finalize=True)
window.FindElement('btnGenerate').Widget.config(activebackground='#273c75',
activeforeground='white')
window.FindElement('btnExit').Widget.config(activebackground='#273c75',
activeforeground='white')
window.FindElement('btnOpenOutput').Widget.config(
activebackground='#273c75', activeforeground='white')
window[active_radio_button].update(button_color=selected_color)
for key, _ in radio_keys.items():
window.FindElement(key).Widget.config(activebackground='#273c75',
activeforeground='white')
# Event Loop to process "events" and get the "values" of the inputs
while True:
event, values = window.read(timeout=50)
if event in ('btnExit', 'Exit',
None): # if user closes window or clicks exit
break
# if another porject is select, load the corresponding configuration files
if event in 'dbProject':
CURRENT_PROJECT_PATH = str(Path(PATH_PROJECT, values['dbProject']))
speaker_file_path = Path(CURRENT_PROJECT_PATH, "speakers.json")
if speaker_file_path.is_file():
with open(speaker_file_path, 'r') as json_file:
speaker_data = json.load(json_file)
speaker_list = [speaker for speaker, _ in speaker_data.items()]
max_length_name = len(max(speaker_list, key=len)) + 2
window['dbSpeaker'].update(values=speaker_list)
window['dbSpeaker'].set_size(size=(max_length_name, None))
else:
window['dbSpeaker'].update(values=["Default"])
window['dbSpeaker'].set_size(size=(len("Default"), None))
# select emotion weights from dropdown gui element
if event in 'dbEmotion':
emotions = get_emotion_weights(values['dbEmotion'].lower())
for k, v in emotions.items():
window[k].update(v)
if event in radio_keys:
for k in radio_keys:
window[k].update(button_color=sg.theme_button_color())
window[event].update(button_color=selected_color)
for key, value in radio_image_keys.items():
if key == event:
window[value].update(data=CHECK_ICON)
else:
window[value].update(data=UNCHECK_ICON)
active_radio_button = event
# open a prompt if the user wants to generate speech from an input file, textbox will be disabled
if event in 'btnFileBrowse':
path_to_textfile = sg.PopupGetFile(
'Please select a file or enter the file name',
default_path=ROOT_PATH,
initial_folder=ROOT_PATH,
icon='g.ico',
no_window=True,
keep_on_top=True,
file_types=(('Text file', '.txt'), ))
if path_to_textfile:
sentence_file = path_to_textfile
text_memory = window['textInput'].get()
window['textInput'].update(
disabled=True,
background_color='#a7a5a5',
value=
f'Using textfile for speech generation: {path_to_textfile}'
)
window['btnCloseFileLoad'].update(visible=True)
if event in 'btnCloseFileLoad':
window['btnCloseFileLoad'].update(visible=False)
sentence_file = ''
window['textInput'].update(disabled=False,
background_color=TEXTINPUT_BACKGROUND)
window['textInput'].update(text_memory)
# open the output folder of the currently selected speaker
if event in 'btnOpenOutput':
if Path(CURRENT_PROJECT_PATH, 'output', current_date,
values['dbSpeaker']).is_dir():
speaker_path = Path(CURRENT_PROJECT_PATH, 'output',
current_date, values['dbSpeaker'])
open_output_folder(speaker_path=speaker_path)
else:
default_path = Path(CURRENT_PROJECT_PATH, 'output')
open_output_folder(speaker_path=default_path)
# stop synthezising speech
if event in 'btnGenerate' and thread:
if values['create_all']:
stop_threads = True
# start synthezising speech from the input
if event in 'btnGenerate' and not thread:
text = values['textInput'].replace('\n', '')
if text or sentence_file:
if values['dbSpeaker'] in 'Default':
speakers_file = ''
speaker_name = "Default"
else:
speakers_file = Path(CURRENT_PROJECT_PATH, 'speakers.json')
speaker_name = values['dbSpeaker']
if values['create_all']:
window['btnGenerate'].update(text='Cancel',
button_color=('white',
'#ff5e5e'))
speaker = speaker_list if values['create_all'] else [
speaker_name
]
vocoder = [
val for key, val in radio_keys.items()
if active_radio_button == key
][0]
gst_dict['0'] = round(float(values['speedSlider'] / 100), 5)
emotion_temp = round(float(values['emotionSlider'] / 100), 5)
gst_dict['1'] = emotion_temp
if values['emotionSlider'] > 0:
gst_dict['2'] = round(emotion_temp - 0.010, 5)
elif values['emotionSlider'] < 0:
gst_dict['2'] = round(emotion_temp + 0.010, 5)
else:
gst_dict['2'] = emotion_temp
gst_dict['5'] = round(float(values['toneSlider'] / 100), 5)
# run speech generation in a new thread
thread = threading.Thread(
target=synthesize_tts,
args=(
text,
values['use_cuda'],
True, # use gst
gst_dict,
CURRENT_PROJECT_PATH,
speaker_list,
speaker,
str(vocoder),
sentence_file),
daemon=True)
thread.start()
loadingAnimation.Update(filename=LOADING_GIF, visible=True)
else:
sg.Popup(
'Type something into the textbox or select a file to generate speech.',
title='Missing input!',
line_width=65,
icon='g.ico')
window['textInput'].SetFocus()
if status: # If gen process finish -> stop loading.gif and open output folder
print('Finished')
loadingAnimation.Update(filename=LOADING_GIF, visible=False)
if Path(CURRENT_PROJECT_PATH, 'output').is_dir():
speaker_path = Path(CURRENT_PROJECT_PATH, 'output',
current_date, speaker_name)
open_output_folder(speaker_path=speaker_path)
status = False
if thread: # If thread is running display loading gif
loadingAnimation.UpdateAnimation(source=LOADING_GIF,
time_between_frames=100)
thread.join(timeout=0)
if not thread.is_alive(): # the thread finished
loadingAnimation.Update(filename=LOADING_GIF, visible=False)
window['btnGenerate'].update(text='Generate',
button_color=('white', '#40739e'))
thread = None # reset variable for next run
window.close()
def make_window_test_model_params(models_list):
"""
Creates window layout for performing testing of the model
:param models_list: list of all created models' names
:type models_list: list[str]
:return: window with functionality of setting parameters for testing the model
:rtype: PySimpleGUI.PySimpleGUI.Window
"""
layout = [
[
sg.Button("Back", enable_events=True, key="-BACK-")
],
[
sg.T(' ' * 21),
sg.Text("Model")
],
[
sg.DropDown(models_list, tooltip="Select model to test", size=(35, 10), enable_events=True, key="-MODEL-")
],
[
sg.T(' ')
],
[
sg.T(' ' * 3),
sg.Text("Distribution of test and train sets"),
],
[
sg.Slider(range=(1, 100), orientation='h', size=(30, 10), default_value=25,
enable_events=True, key="-TEST SIZE-")
],
[
sg.Text("Test set size:"),
sg.Text("000", enable_events=True, key="-TEST-"),
sg.Text("Training set size:"),
sg.Text("000", enable_events=True, key="-TRAINING-"),
],
[
sg.T(' ')
],
[
sg.Text("Measures of quality")
],
[
sg.Check("Coefficient of determination", default=True, key="-R SQUARE-"),
],
[
sg.Check("Mean error of point's position", default=True, key="-MEAN ERROR-"),
],
[
sg.Check("Explained variance", default=True, key="-EXPLAINED VARIANCE-"),
],
[
sg.T(' ')
],
[
sg.T(' ' * 20),
sg.Button("Test model", enable_events=True, key="-SUBMIT BUTTON-")
],
]
return sg.Window("Test params", layout, finalize=True)
def _create_window_for_markup(screen_size, title):
commands_m = [
sg.Text('Manipulations: '),
sg.Button('Split (S)troke', key='split_stroke'),
sg.Button('Split (C)haracter', key='split_char'),
sg.Button('Split (T)rial', key='split_trial'),
sg.Button('(M)erge characters', key='merge_chars'),
sg.Button('(R)eset current trial', key='reset_trial'),
sg.Button('(D)elete stroke', key='delete_stroke'),
sg.Button('Sel(f) correction', key='self_correction'),
sg.Checkbox('Show correction strokes',
key='show_correction',
enable_events=True,
disabled=True),
]
commands_nav = [
sg.Text('Navigation / decision: '),
sg.Button('(A)ccept as OK', key='accept'),
sg.Button('Err(o)r:', key='accept_error'),
sg.DropDown(markup_config['error_codes'],
key='error',
enable_events=True,
readonly=True),
sg.Button('s(K)ip current trial', key='skip_trial'),
sg.Button('(P)revious trial', key='prev_trial'),
sg.Button('(G)o to specific trial', key='choose_trial'),
sg.Button('Enter response', key='response'),
#sg.Txt('Enter response:'),
#sg.Input(key = 'text_response', enable_events= True),
]
commands_general = [
sg.Button('S(E)ttings', key='settings'),
sg.Button('(Q)uit WEncoder', key='quit'),
]
layout = [[
sg.Text(' ' * 100,
text_color='white',
key='instructions',
font=('Arial', 16))
],
[
sg.Graph(screen_size, (0, screen_size[1]),
(screen_size[0], 0),
background_color='Black',
key='graph',
enable_events=True)
], commands_m, commands_nav, commands_general]
label = tk.Label(text="Hello, Tkinter", fg="white", bg="yellow")
label.pack()
window = sg.Window(title,
layout,
return_keyboard_events=True,
resizable=True)
window.Finalize()
#window.Maximize()
return window
def show_settings_screen(show_cancel_button=True):
"""
Open the 'settings' window
"""
show_popup = True
warning = ''
while show_popup:
buttons = [sg.Button('OK')]
if show_cancel_button:
buttons.append(sg.Button('Cancel'))
layout = [
[sg.Text(warning, text_color='red')],
[
sg.Text('Typing in the participants\'s response is '),
sg.DropDown(_response_mandatory_options,
default_value=_response_mandatory_options[
app_config['response_mandatory'].value],
readonly=True,
key='response_mandatory')
],
[
sg.Text(
'Merge 2 strokes into one character if their horizontal overlap exceeds'
),
sg.InputText('{:.1f}'.format(
100 * app_config['max_within_char_overlap']),
key='max_within_char_overlap'),
sg.Text('percent')
],
[
sg.Text('Error codes (comma-separated list): '),
sg.InputText(','.join(app_config['error_codes']),
key='error_codes')
],
[
sg.Text('The size of dots for plotting the trajectories: '),
sg.DropDown(['1', '2', '3', '4', '5'],
readonly=True,
key='dot_radius',
default_value=str(app_config['dot_radius']))
],
buttons,
]
window = sg.Window('Settings', layout)
event = None
clicked_ok = False
values = {}
while event is None:
event, values = window.Read()
clicked_ok = event == 'OK'
window.Close()
if clicked_ok:
try:
max_within_char_overlap = float(
values['max_within_char_overlap'])
except ValueError:
warning = 'Invalid "Maximal overlap" value'
continue
if not (0 < max_within_char_overlap < 100):
warning = 'Invalid "Maximal overlap" value (expecting a value between 0 and 100)'
continue
error_codes = values['error_codes']
if not re.match('([a-zA-Z_]+)(,[a-zA-Z_]+)*', error_codes):
warning = 'Error codes must be a comma-separated list of letter codes, without spaces'
continue
app_config['response_mandatory'] = ResponseMandatory(
_response_mandatory_options.index(
values['response_mandatory']))
app_config[
'max_within_char_overlap'] = max_within_char_overlap / 100
app_config['error_codes'] = error_codes.split(',')
app_config['dot_radius'] = int(values['dot_radius'])
show_popup = False
else:
show_popup = False
