see also #4

Which means instead of this:

the right way to check if an array has something in it is:

if alarms:
   # do something with it

Same goes for strings (anything other than '' is true), dicts, sets, etc.

Look at this code:

        file = open(self.file_to_alarms, "r")
        alarm_text = file.readlines()
        alarms = [[alarm_text[i][0], alarm_text[i][1], alarm_text[i][2], alarm_text[i][3]] for i in range(len(alarm_text))]

Here, at first you read in the whole file. This particular file is never gonna be huge, but loading whole files into memory is more or less never a good idea, since in most cases you'll be processing them in pieces; in this case line by line. You probably didn't learn this yet, but the proper way of doing that is to simply iterate over the file. So instead of loading it in its entirety and then iterating by creating indices using range(len(...)), this is what it should look like:

        with open(self.file_to_alarms, "r") as file:
            alarms = []
            for line in file:
                alarms.append([int(digit) for digit in line.strip()])

The .strip() call removes the linebreak that is included at the end of the line (if there is more than one line in the file). The conversion to int is obviously necessary and missing in your original code above, so the function in its current state produces an array of strings (i.e. is broken).

What this version does better is that it only reads one line at a time, processes it, and immediately releases its memory. Unless you have a really good reason, always read files this way and forget that .readlines() exists.

One issue with my version is that it's not guaranteed to return a list of four ints, while yours does. On the other hand, yours will throw an error if for some reason, the line is shorter than four characters. But in reality, none of these should be a problem since the file is produced somewhere else and its integrity should be guaranteed there, while here you should assume it's well-formed because it doesn't come from an untrusted or unreliable source. If you want to make sure the lists are of the right length, you could do this instead:

        with open(self.file_to_alarms, "r") as file:
            alarms = []
            for line in file:
                digits = [int(digit) for digit in line.strip()]
                assert len(digits) == 4, f'Size mismatch: { len(digits) } characters instead of 4'
                alarms.append(digits)

The assertion will throw an error if the condition is not satisfied, but again, I think this is overkill.

Yes, it's longer, but:

• it does more (conversion to int)
• it replaces repetition plus hard-coded indices (last line in the top code box) with iteration
• it's clearer
• it can still be turned into a one-liner (that will be shorter than the original, btw.) if you really want to optimize for number of lines instead of readability

When listing the alarms, I need to better handle the case where no alarm has been set.
A audio message would be useful.

It seems that a more appropriate setup would be to retain the last volume used for any given player or track within the player.

Instead of

                if button_index == 0:
                    self.clock.set_alarm(add = [1, 0, 0, 0])
                elif button_index == 1:
                    self.clock.set_alarm(add = [0, 1, 0, 0])
                elif button_index == 2:
                    self.clock.set_alarm(add = [0, 0, 1, 0])
                elif button_index == 3:
                    self.clock.set_alarm(add = [0, 0, 0, 1])

Why not

                delta = [0, 0, 0, 0]
                delta[button_index] = 1
                self.clock.set_alarm(add=delta)

For now when the volume is changed, the user does not realize by how much the volume has changed.
So we would need a sound that is produced while the rotary dial is turned to indicate that.
The sound should either be very short or quite continuous for this to work.
https://pixabay.com/sound-effects/ seems to be a good source for sounds.

It would make the code a little cleaner to pack everything focussed on the physical box within one class.

The with statement creates a block which queues up an operation when the block is exited. In case of opening files, it allows you to omit the file.close() call. It's used like this:

with open(filename) as infile:
    for line in infile:
        print(line)
# here 'infile' is closed automatically

Not sure whether you already learned about the ability to filter inside a list comprehension:

        self.tracks_files = [file for file in files_in_path_music if file.endswith('mp3') or file.endswith('wav')]

The comment below there mentions that filenames should start with a number, which this test doesn't detect, but neither does the regex in the original code.

For now, the way I programmed it is clunky has action depend on release, so the user may hold for longer than necessary.

As in

def update_volume(self, vol, verbose=True): 

It's a very simple thing that I'd handle with a lambda

For now the modes are changing in circle when pressing for a long time on the rotary encoder.
I think a better experience would be that when pressing long, the user would be asked to select among up to 4 modes by pressing on one of the top button.
This would be more direct and would allow for more modes.

At the moment one has to preset an alarm to list or delete all existing alarms...

Since "self" isn't used anywhere inside it, it should either be free function or a class method, if you prefer to bind it to the class

The problem is that the default value doesn't mean "create an empty dict every time no value is provided", but "use this exact dict that is created in the function definition". So if you call a function without providing an alternative value, and modify the dict (same applies to lists, sets, etc.), then all following calls that also use the default value will see that change. They will all work on the exact same dict object. So do this instead:

def func(x=None):
    if x is None:
        x = {}

We need a sound to play when there is an error and code to detect errors.
That should include #14.

In the class Clock, several methods use time.sleep() to make sure a given sound is fully played until the next one is being produced. The timing is thus hardcoded, which is annoying and not robust to change.
Instead I should check the status of the player and decide what to do if something is being played already (wait, stop, overlap).

I don't know what you are planning to do with this method, but from the pure mathematical point of view this is highly questionable.

If you are planning to have functionality that shifts the alarm by a certain number of hours and minutes, then I'd rather do that with proper mixed radix integers, 24 and 60, instead of tracking each digit separately.

It seems that when an alarm is cancelled it creates troubles to set an alarm after that

Here's the URL

It uses reStructuredText as syntax, which is similar to Markdown but better suitable for technical documents, as it allows you to e.g. mark a string as a method and will automatically make it a link to the file containing the description of that method's class, and automatically create a table of contents and such. I think it should also be possible to set it up to extract the docstrings from the code, so you could have the code and the documentation together if you think that's better.

I think GitHub will convert reST to HTML as it does with Markdown, so no need to write everything twice.

First, having the same string here and in the preceding line with the if is redundant, and creates room for typos (correct string in the if, string with a typo in the assignment). I'd suggest something like:

    def change_mode(self, mode):
        if mode == "alarm":
            self.clock.reset_soft(vol = 0)
        elif mode not in ["alarm_validation", "player_night"]:
            raise ValueError('Unknown mode: ' + mode)

        self.mode_current = mode
        tracks = { # this dictionary should be outside of this function, possibly something like self.sounds
            "alarm": "alarm_mode.wav",
            "alarm_validation": "alarm_validation.mp3",
            "player_night": "player_night_mode.wav",
        }
        # NB: no spaces around equal signs inside function calls
        self.player_system.play_sound(track_name=tracks[mode], vol=self.volume_current)
        print(self.mode_current)