jobqueue | Jobqueue manages running and scheduling jobs | Job Scheduling library

There are a few issues with your code, let me try to point them out:

1. def callback_msgs(): fetch_msgs() You use callback_msgs as callback for your job. But job callbacks take exactly one argument of type telegram.ext.CallbackContext.

Printing every name in each 2 second interval:

the underlying object can process one request at a time, so the wrapper needs to queue the request, and when the "processing done" event arrives, it needs to return the result to the appropriate client.

So what you need is mutual exclusion. While you can build a mutex from TPL Dataflow and TaskCompletionSource, it's much easier to just use the built-in one, SemaphoreSlim.

IMO it's cleaner to first write an async abstraction, and then add the mutual exclusion. The async abstraction would look like:

from telegram.ext import Updater

add .ext

Not really, Access can't join on long text (memo) fields.

A common workaround is to truncate the field before joining, e.g. ON LEFT(LongTextField, 255) = LEFT(ForeignLongTextField, 255). However, this may cause unintended matches, especially when using code as the key, since there may be a difference beyond the first 255 characters.

A more difficult, but more proper solution is to use a hash as the join key, and join on the hash, e.g.

ok so I found a solution. I am not sure what the problem was, but you can override the memory issue by overriding the memory requirement using the header_skip option. So change the line from

From man parallel:

There is a a small issue when using GNU parallel as queue system/batch manager: You have to submit JobSlot number of jobs before they will start, and after that you can submit one at a time, and job will start immediately if free slots are available. Output from the running or completed jobs are held back and will only be printed when JobSlots more jobs has been started (unless you use --ungroup or --line-buffer, in which case the output from the jobs are printed immediately). E.g. if you have 10 jobslots then the output from the first completed job will only be printed when job 11 has started, and the output of second completed job will only be printed when job 12 has started.

In other words: The jobs are running. Output is delayed. It is easier to see if you instead of using echo in your example use touch unique-file-name.

I'm thinking that the section of the Python API (advanced) in the docs might be a good way to try to solve this issue.

Mind you this is an example of how to create Schedulers and Workers, but I'm assuming that the logic could be used in a similar way for your case.

The data in a Qt item model should always be set using setData().

The obvious reason is that the default implementations of item views always call that method whenever the data is modified by the user (eg. manually editing the field), or more programmatically (checking/unchecking a checkable item, like in your case). The other reason is for more consistency with the whole model structure of Qt framework, which should not be ignored.

In any way, the most important thing is that whenever the data is changed, the dataChanged() signal must be emitted. This ensures that all views using the model are notified about the change and eventually update themselves accordingly.

So, while you could manually emit the dataChanged signal from your randomizeSelected function, I would advise you against so.
The dataChanged should only be emitted for the indexes that have actually changed. While you could theoretically emit a generic signal that has the top-left and bottom-right indexes, it's considered bad practice: the view doesn't know what data (and role) has changed and if it gets a signal saying that the whole model has changed it will have to do lots of computations; even if those computations might seem to happen instantly, if you only change even a single index text they become absolutely unnecessary. I know that yours is a very simple model, but for learning purposes it's important to keep this in mind.
On the other hand, if you want to correctly emit the signal for the changed index alone, this means that you need to manually create the model.index() correctly, making the whole structure unnecessary complex, especially if at some point you need more ways to change the data.
In any case, there's no direct and easy way to do so when dealing with checkable items, since it's up to the view to notify the model about the check state change.

Using setData() allows you to have a centralized way to actually set the data to the model and ensure that everything is correctly updated accordingly. Any other method is not only discouraged, but may lead to unexpected behavior (like yours).

Finally, abstract models only have the ItemIsEnabled and ItemIsSelectable flags, so in order to allow checking and uncheking items, you need to override the flags() method too to add the ItemIsUserCheckable flag, and then implement the relative check in the setData().