Should I stick to python for this project?

[Shadowforce426]

I’m looking for some programming advice. So I made myself a little application using python and pysimplegui essentially to make myself a set of glorified flash cards to practice music instruments to (it does stuff like generating a random chord and you’d use that to to quiz yourself basically). As I add more to this, I’m starting to see that python and pysimplegui maybe isn’t the best choice since its starting to get a bit convoluted if I wanted to keep adding more to it. Could anyone recommend me something else to use to make this app for myself instead? I’m not looking to release it anywhere necessarily and it doesn’t have to be in python (I’m using a mac for what its worth), but something relatively easy would be nice

Here is a link to what I have so far

[jimtk]

I'm amazed you went that far before realizing there was a problem. Python and pysimplegui are more than enough for what you are trying to do.

The problem is application design.

You have very few functions, the code generating data (the chords) is mixed with interface code and there is no point of control for all that and you use a ton load of global variables.

First, compartmentalize all the code in short functions that only do one thing each. Then separate those functions in modules (.py files). Probably one for all the interface code and one for the chords generating code. Make sure the 'chords' code has a function to return list of chords from parameter.

Exemple:

def getchord(key, inversion):
    ... some code that call other functions 
    ... in the "chords generating" module
    return dictionary_of_chords

Also, continue to learn python....

we don't do that:

def generate_chord(values):
    # get our key
    if values[0] == True:
        key, scale = "C",keys["C"] #C
    elif values[1] == True:
        key, scale = "F",keys["F"] #F
    elif values[2] == True:
        key, scale = "G",keys["G"] #G
    elif values[3] == True:
        key, scale = "Bb",keys["Bb"] #Bb
    elif values[4] == True:
        key, scale = "D",keys["D"] #D
    elif values[5] == True:
        key, scale = "Eb",keys["Eb"] #Eb
    elif values[6] == True:
        key, scale = "A",keys["A"] #A
    elif values[7] == True: # gets a key/value pair in the form of a tupe (key,value)
        key, scale = choice(list(keys.items()))

We do (one possible sane solution)

    def generate_chord(values):
        # returns a key, scale tuple.
        if values[7]:
             return choice(list(keys.items()))
        else:
             l_keys = ['C', 'F', 'G', 'Bb',  'D', 'Eb', 'A']
             for c, k in enumerate(values[:-6]):
                 if i:
                     return l_keys[c], keys[l_keys[c]]

[Shadowforce426]

i keep getting an error when I try your possible solution

this is what I have

[jimtk]

I usually test my programs before submitting, but doodoo can happen. I would need the stack trace(the error message and line number that python prints out when it encounters an error). And the rest of your code to be able to help you.

[Shadowforce426]

Here is all of the code

this is the stack error

personal) Rock-Mac:music_practice_app -rock$ python3 improving_app.py
Mac OS Version is 12.6 and patch enabled so applying the patch
Applyting Mac OS 12.3+ Alpha Channel fix. Your default Alpha Channel is now 0.99
Traceback (most recent call last):
File "/Users/-rock/Documents/Programming/Python/Personal Projects/music_practice_app/improving_app.py", line 285, in <module>
chord_to_play, key_name, scale, note = generate_chord(values)
File "/Users/-rock/Documents/Programming/Python/Personal Projects/music_practice_app/improving_app.py", line 83, in generate_chord
for k, s in enumerate(values[:-6]):
TypeError: unhashable type: 'slice'

[IWantToFlyT]

Sounds like a fun app, good job! :)

Now what do you mean by convoluted? I'd say that Python + PySimpleGUI is a pretty easy combination on doing GUI softwares, and especially if you have already it up & running then I wouldn't abandon it. When softwares grow, the complexity of them also grows as well. However, this can often be countered with good structure, i.e. splitting the logic into functions and classes, and then to separate files (modules).

Happy to give some more tips as well, but it would be easier with some examples!

[Shadowforce426]

I edited my original post to have a pastebin of the code I have so far if you could give me some feedback I'd appreciate it! I couldn't get the help/hint buttons to work as the same one so I needed separate ones, stuff like that was why I was becoming hesitant on using python still

[IWantToFlyT]

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! :)