class napari.qt.threading.WorkerBase(*args, SignalsClass=<class 'napari._qt.qthreading.WorkerBaseSignals'>, **kwargs)

Bases: PyQt5.QtCore.QRunnable

Base class for creating a Worker that can run in another thread.

Parameters

SignalsClass (type, optional) – A QObject subclass that contains signals, by default WorkerBaseSignals

signals

signal emitter object. To allow identify which worker thread emitted signal.

Type

WorkerBaseSignals

Methods

autoDelete(self)
create(Callable[[], None])
quit()	Send a request to abort the worker.
run()	Start the worker.
setAutoDelete(self, bool)
start()	Start this worker in a thread and add it to the global threadpool.
work()	Main method to execute the worker.

Attributes

abort_requested	Whether the worker has been requested to stop.
is_running	Whether the worker has been started

Details

property abort_requested

Whether the worker has been requested to stop.

Return type

bool

autoDelete(self) → bool

create(Callable[[], None]) → QRunnable

property is_running

Whether the worker has been started

Return type

bool

quit()

Send a request to abort the worker.

Note

It is entirely up to subclasses to honor this method by checking self.abort_requested periodically in their worker.work method, and exiting if True.

Return type

None

run()

Start the worker.

The end-user should never need to call this function. But it cannot be made private or renamed, since it is called by Qt.

The order of method calls when starting a worker is:

calls QThreadPool.globalInstance().start(worker)
|               triggered by the QThreadPool.start() method
|               |             called by worker.run
|               |             |
V               V             V
worker.start -> worker.run -> worker.work

This is the function that actually gets called when calling QThreadPool.start(worker)(). It simply wraps the work() method, and emits a few signals. Subclasses should NOT override this method (except with good reason), and instead should implement work().

setAutoDelete(self, bool)

start()

Start this worker in a thread and add it to the global threadpool.

The order of method calls when starting a worker is:

calls QThreadPool.globalInstance().start(worker)
|               triggered by the QThreadPool.start() method
|               |             called by worker.run
|               |             |
V               V             V
worker.start -> worker.run -> worker.work

work()

Main method to execute the worker.

The end-user should never need to call this function. But subclasses must implement this method (See GeneratorFunction.work() for an example implementation). Minimally, it should check self.abort_requested periodically and exit if True.

Examples

class MyWorker(WorkerBase):

    def work(self):
        i = 0
        while True:
            if self.abort_requested:
                self.aborted.emit()
                break
            i += 1
            if i > max_iters:
                break
            time.sleep(0.5)

Return type

Union[Exception, Any]