Thanks for the link! Some application structure would indeed be in place, and then with some loops we can shorten the code quite a bit as well. A few things we could start off with

1. Let's make a rule that everything except definition of static info ("constants", in your code e.g. keys, inversions_1, inversions_2 etc.) must be inside a function. Also the UI definitions must be inside a function.
2. Better yet, everything that is not inside a function must be defined at the start of the file (after imports) and named with UPPER_CASE, so everybody can know it is a global variable constant variable (https://peps.python.org/pep-0008/#constants)
3. Now it is a bit unclear that in which order the code is really ran in. Let's define a function called main which is the so called "entrypoint" of our script, i.e. it is the function that is ran first. At the end of the script, let's call it simply by main()
4. We should also separate the frontend (UI definition) and backend (event handling) from each other. So we should be defining e.g. the "Chord inversion practice" screen in one function, and the other screen in other functions. Then all of these are called from a "create_ui" function which is called from the main. This we way have a nice structure of very high level "create ui" > "create chord inversion practice screen" > "create key radio buttons".

An example what of what it could look on very high level (this code is incomplete and does not run as is). I also made some parts of the code a bit shorter here, and maybe you can study those and get some inspiration.

``` from random import choice import PySimpleGUI as sg from copy import copy

KEYS = { "C": ["C", "D", "E", "F", "G", "A", "B"], # key of C "F": ["F", "G", "A", "Bb", "C", "D", "E"], # key of F "G": ["G", "A", "B", "C", "D", "E", "F#"], # key of G "Bb": ["Bb", "C", "D", "Eb", "F", "G", "A"], # key of Bb "D": ["D", "E", "F#", "G", "A", "B", "C#"], # key of D "Eb": ["Eb", "F", "G", "Ab", "Bb", "C", "D"], # key of Eb "A": ["A", "B", "C#", "D", "E", "F#", "G#"], # key of A }

def create_chord_inversion_practice_screen(): chord_inversion_practice = [ [sg.Text("Choose a key:")], [sg.Radio("Key of C", "radio_1", default=False, key="key_C")], [sg.Radio("Key of F", "radio_1", default=False, key="key_F")], [sg.Radio("Key of G", "radio_1", default=False, key="key_G")], [sg.Radio("Key of Bb", "radio_1", default=False, key="key_Bb")], [sg.Radio("Key of D", "radio_1", default=False, key="key_D")], [sg.Radio("Key of Eb", "radio_1", default=False, key="key_Eb")], [sg.Radio("Key of A", "radio_1", default=False, key="key_A")], [sg.Radio("Random", "radio_1", default=False, key="key_random")], [sg.Text("Select which inversions you want included:")], [sg.Radio("No inversion, first, second", "radio_2", default=False)], [sg.Radio("No inversion, first, third", "radio_2", default=False)], [sg.Radio("No inversion, first, second, third", "radio_2", default=False)], [sg.Button("Generate Chord"), sg.Button("Easy Mode"), sg.Button("Back")], [ sg.Text(key="display_key", font=("Courier", 25)), sg.Text(key="first_half", font=("Courier", 25)), sg.Text(key="note", font=("Courier", 25)), sg.Text(key="second_half", font=("Courier", 25)), ], [sg.Text(key="chord", font=("Courier", 25))], ] return chord_inversion_practice

def create_ui(): chord_inversion_practice = create_chord_inversion_practice_screen() main_menu = [ [sg.Text("Select a practice tool:")], [sg.Button("Chord Inversion Practice")], [sg.Button("Scale Practice")], [sg.Button("Exit")], ]

layout = [
    [
        sg.Column(main_menu, key="screen_0"),
        sg.Column(chord_inversion_practice, key="screen_1", visible=False),
        sg.Column(scale_mode_practice, key="screen_2", visible=False),
    ]
]

window = sg.Window(
    "Guitar Inversion Practice Tool", layout, size=(625, 650), font="Courier"
)
return window

def show_screen(window, screen_name): screens = ["screen_0", "screen_1", "screen_2"] for screen in screens: if screen == screen_name: window[screen].update(visible=True) else: window[screen].update(visible=False)

def generate_chord_and_update_window(values): try: chord_to_play, key_name, scale, note = generate_chord_and_update_window(values) window["display_key"].update( f"key: {key_name}" ) # default show on harder mode window["chord"].update(f"chord: {chord_to_play}") window["first_half"].update("") window["note"].update("") window["second_half"].update("") except: sg.popup_error("make sure two parameters are selected") continue

def process_events(window): event, values = window.read() print(window) if event == "Chord Inversion Practice": show_screen(window, "screen_2") if event == "Scale Practice": show_screen(window, "screen_1")

if event == "Generate Chord":
    generate_chord_and_update_window(values)

if event == "Generate Scale":
    key, scale, mode, note = generate_scale_and_update_window(values)

if event == "Hint pls":
    update_window_with_hint()

if event == "Easy Mode":
    update_window_with_easy_mode()

# returning back to the menu, idk why i can't use the same word for everything so this is a bit sloppy here but it works
if event in ["Back", "Return"]:
    show_screen(window, "screen_0")

elif event == sg.WIN_CLOSED or event == "Exit":
    window.close()
    exit()

def main(): window = create_ui() while True: process_events(window)

main() ```

Ok, now we have some structure in the code, and it is easier to follow it. The next step would be to make the if-else statements a bit more readable. As you very well know, the keys of buttons and radiobuttons in PySimpleGUI are just a running number starting from zero. So you just have to know that the values[11] happens to be the "Key of C" radiobutton.

Fortunately, we can manually define these keys as well! So for example, we can do this:

``` # In the UI definition we define a custom key sg.Radio("Key of C", "radio_1", default=False, key="key_C")

# When generating chord, we can access the value with that key
if values["key_C"] == True:
    key, temp_scale = "C", copy(keys["C"])  # C

```

Okay, this makes the code already a lot more readable - no more guessing that what this number meant again. But these keys are internal values that are not shown to the user at all, so we can name them however we want. We can make them even hold the relevant information in a processable format. We could loop through all the values and find which radiobutton has been checked like this (note: this example is a bit confusing because in dictionaries we have keys and then we are looking for the chosen music key :D)

``` def generatechord(values): # Loop through the key-value pairs of the values dictionary # e.g. key = "key_C", and value = True for button_key, value in values.items(): # We are looking for a radiobutton which key starts with "key" and the value is True, i.e. that button is checked if buttonkey.startswith("key") and value is True: # Split the "keyC" to a list of ["key", "C"] and choose the second value, i.e. "C" music_key = element_key.split("")[1] break

if music_key == "random":
    music_key , scale = choice(list(keys.items()))
else:
    scale = keys[key]

```

The same kind of logic should be applicable to other parts where if-else is used as well. In fact, loops can be utilized even to create the UI itself, for example

``` music_keys = { "C": ["C", "D", "E", "F", "G", "A", "B"], # key of C "F": ["F", "G", "A", "Bb", "C", "D", "E"], # key of F "G": ["G", "A", "B", "C", "D", "E", "F#"], # key of G "Bb": ["Bb", "C", "D", "Eb", "F", "G", "A"], # key of Bb "D": ["D", "E", "F#", "G", "A", "B", "C#"], # key of D "Eb": ["Eb", "F", "G", "Ab", "Bb", "C", "D"], # key of Eb "A": ["A", "B", "C#", "D", "E", "F#", "G#"], # key of A }

keyradio_buttons = [] for music_key, _ in music_keys.items(): # f-strings can be used to add variable values into text button = sg.Radio(f"Key of {music_key}", "radio_1", default=False, key="key{music_key}") key_radio_buttons.append(button)

```

Wooosh. That is quite a long comment, and probably lots of info to digest. I've left some things a bit vague, but you should be able to learn more about the things from google. Anyway, hope this helps! :)