If I understand it correctly, parameter l is a list and amount is the number of chunks we want to have. Isn't it easier if we pass in the size of chunk instead of number of chunks?

So, we can have a function which splits a list into n-size chunks.

Easier - yes, useful - not as much. The initial idea for dividing workspaces into chunks was to let users divide their workspaces into equal chunks based on the number of CPU cores they have without having to know the amount of pages a workspace has. With the n-size chunks approach the user still needs to know the total amount of pages and decide the N value for different workspaces to get optimal performance on the amount of CPU cores they use. Of course, the list-page could also support n-size chunk division as an additional option if that would be useful for the user. I could implement that.

Yeah, just realized that. Btw, I found this solution, which do not require numpy. It seems fine to me. Did you try it?

def chunks(l, n):
    """Yield n number of sequential chunks from l."""
    d, r = divmod(len(l), n)
    for i in range(n):
        si = (d+1)*(i if i < r else r) + d*(0 if i < r else i - r)
        yield l[si:si+(d+1 if i < r else d)]

It could be even simpler if we don't need to have sequential chunks.

def chunks(l, n):
    """Yield n number of striped chunks from l."""
    for i in range(0, n):
        yield l[i::n]

Ideally, sequential chunks are preferred when possible. It is also easier for reference. For example, it is easier to say pages in ranges 7..11 have failed, than to nail the exact IDs in a failed range. Also easier to rerun tasks on the failed range, e.g., the page_id would be just PHYS_0007..PHYS_0011 instead of writing the full id of 5 pages. The sequence, of course, does not matter for workspaces where the ids are hashes and the shortcut referencing does not work.