ewoksorange.bindings.taskexecutor.ThreadedTaskExecutor#

class ewoksorange.bindings.taskexecutor.ThreadedTaskExecutor[source]#

Bases: QThread, TaskExecutor

Create and execute an Ewoks task in a dedicated thread.

HighPriority = 4#

HighestPriority = 5#

IdlePriority = 0#

InheritPriority = 7#

LowPriority = 2#

LowestPriority = 1#

NormalPriority = 3#

class Priority#: Bases: int

TimeCriticalPriority = 6#

blockSignals(self, b: bool) → bool#

cancel_running_task()[source]#: cancel current processing. The targetted EwoksTask must have implemented the ‘cancel’ function

childEvent(self, a0: QChildEvent | None)#

children(self) → List[QObject]#

connectNotify(self, signal: QMetaMethod)#

create_task(log_missing_inputs=False, **kwargs)#

Parameters:: log_missing_inputs (bool)
Return type:: None

currentThread() → QThread | None#

currentThreadId() → PyQt5.sip.voidptr | None#

property current_task: Task | None#

customEvent(self, a0: QEvent | None)#

deleteLater(self)#

destroyed#: destroyed(self, object: Optional[QObject] = None) [signal]

disconnect(a0: QMetaObject.Connection) → bool#
disconnect(self) → None

disconnectNotify(self, signal: QMetaMethod)#

property done: bool | None#: Returns None when the task was not or could not be instantiated

dumpObjectInfo(self)#

dumpObjectTree(self)#

dynamicPropertyNames(self) → List[QByteArray]#

event(self, event: QEvent | None) → bool#

eventDispatcher(self) → QAbstractEventDispatcher | None#

eventFilter(self, a0: QObject | None, a1: QEvent | None) → bool#

property exception: Exception | None#: The instantiation exception, the execution exception or None

exec(self) → int#

exec_(self) → int#

execute_task()#

Return type:: None

exit(self, returnCode: int = 0)#

findChild(self, type: Type[QObjectT], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT#
findChild(self, types: Tuple[Type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT

findChildren(self, type: Type[QObjectT], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]#
findChildren(self, types: Tuple[Type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, type: Type[QObjectT], regExp: QRegExp, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], regExp: QRegExp, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, type: Type[QObjectT], re: QRegularExpression, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], re: QRegularExpression, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]

finished#: finished(self) [signal]

property has_task: bool#

idealThreadCount() → int#

inherits(self, classname: str | None) → bool#

installEventFilter(self, a0: QObject | None)#

isFinished(self) → bool#

isInterruptionRequested(self) → bool#

isRunning(self) → bool#

isSignalConnected(self, signal: QMetaMethod) → bool#

isWidgetType(self) → bool#

isWindowType(self) → bool#

killTimer(self, id: int)#

loopLevel(self) → int#

metaObject(self) → QMetaObject | None#

moveToThread(self, thread: QThread | None)#

msleep(a0: int)#

objectName(self) → str#

objectNameChanged#: objectNameChanged(self, objectName: Optional[str]) [signal]

property output_variables: dict | None#

parent(self) → QObject | None#

priority(self) → QThread.Priority#

property(self, name: str | None) → Any#

pyqtConfigure(...)#: Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

quit(self)#

receivers(self, signal: PYQT_SIGNAL) → int#

removeEventFilter(self, a0: QObject | None)#

requestInterruption(self)#

run()[source]#

Return type:: None

sender(self) → QObject | None#

senderSignalIndex(self) → int#

setEventDispatcher(self, eventDispatcher: QAbstractEventDispatcher | None)#

setObjectName(self, name: str | None)#

setParent(self, a0: QObject | None)#

setPriority(self, priority: QThread.Priority)#

setProperty(self, name: str | None, value: Any) → bool#

setStackSize(self, stackSize: int)#

setTerminationEnabled(enabled: bool = True)#

signalsBlocked(self) → bool#

sleep(a0: int)#

stackSize(self) → int#

start(self, priority: QThread.Priority = QThread.InheritPriority)#

startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) → int#

started#: started(self) [signal]

staticMetaObject = <PyQt5.QtCore.QMetaObject object>#

stop(timeout=None, wait=False)[source]#

Stop the current thread

Parameters:

timeout (Optional[float])
wait (bool)

Return type:

None

property succeeded: bool | None#: Returns None when the task was not or could not be instantiated

terminate(self)#

thread(self) → QThread | None#

timerEvent(self, a0: QTimerEvent | None)#

tr(self, sourceText: str | None, disambiguation: str | None = None, n: int = -1) → str#

usleep(a0: int)#

wait(self, msecs: int = ULONG_MAX) → bool#
wait(self, deadline: QDeadlineTimer) → bool

yieldCurrentThread()#