class CanvasView(QGraphicsView):
"""Canvas View handles the zooming.
"""
def __init__(self, *args):
super().__init__(*args)
self.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.__backgroundIcon = QIcon()
self.__autoScroll = False
self.__autoScrollMargin = 16
self.__autoScrollTimer = QTimer(self)
self.__autoScrollTimer.timeout.connect(self.__autoScrollAdvance)
# scale factor accumulating partial increments from wheel events
self.__zoomLevel = 100
# effective scale level(rounded to whole integers)
self.__effectiveZoomLevel = 100
self.__zoomInAction = QAction(
self.tr("Zoom in"), self, objectName="action-zoom-in",
shortcut=QKeySequence.ZoomIn,
triggered=self.zoomIn,
)
self.__zoomOutAction = QAction(
self.tr("Zoom out"), self, objectName="action-zoom-out",
shortcut=QKeySequence.ZoomOut,
triggered=self.zoomOut
)
self.__zoomResetAction = QAction(
self.tr("Reset Zoom"), self, objectName="action-zoom-reset",
triggered=self.zoomReset,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0)
)
def setScene(self, scene):
super().setScene(scene)
self._ensureSceneRect(scene)
def _ensureSceneRect(self, scene):
r = scene.addRect(QRectF(0, 0, 400, 400))
scene.sceneRect()
scene.removeItem(r)
def setAutoScrollMargin(self, margin):
self.__autoScrollMargin = margin
def autoScrollMargin(self):
return self.__autoScrollMargin
def setAutoScroll(self, enable):
self.__autoScroll = enable
def autoScroll(self):
return self.__autoScroll
def mousePressEvent(self, event):
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
if not self.__autoScrollTimer.isActive() and \
self.__shouldAutoScroll(event.pos()):
self.__startAutoScroll()
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if event.button() & Qt.LeftButton:
self.__stopAutoScroll()
return super().mouseReleaseEvent(event)
def wheelEvent(self, event: QWheelEvent):
if event.modifiers() & Qt.ControlModifier \
and event.buttons() == Qt.NoButton:
delta = event.angleDelta().y()
# use mouse position as anchor while zooming
anchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__setZoomLevel(self.__zoomLevel + 10 * delta / 120)
self.setTransformationAnchor(anchor)
event.accept()
else:
super().wheelEvent(event)
def zoomIn(self):
self.__setZoomLevel(self.__zoomLevel + 10)
def zoomOut(self):
self.__setZoomLevel(self.__zoomLevel - 10)
def zoomReset(self):
"""
Reset the zoom level.
"""
self.__setZoomLevel(100)
def zoomLevel(self):
# type: () -> float
"""
Return the current zoom level.
Level is expressed in percentages; 100 is unscaled, 50 is half size, ...
"""
return self.__effectiveZoomLevel
def setZoomLevel(self, level):
self.__setZoomLevel(level)
def __setZoomLevel(self, scale):
self.__zoomLevel = max(30, min(scale, 300))
scale = round(self.__zoomLevel)
self.__zoomOutAction.setEnabled(scale != 30)
self.__zoomInAction.setEnabled(scale != 300)
if self.__effectiveZoomLevel != scale:
self.__effectiveZoomLevel = scale
transform = QTransform()
transform.scale(scale / 100, scale / 100)
self.setTransform(transform)
self.zoomLevelChanged.emit(scale)
zoomLevelChanged = Signal(float)
zoomLevel_ = Property(
float, zoomLevel, setZoomLevel, notify=zoomLevelChanged
)
def __shouldAutoScroll(self, pos):
if self.__autoScroll:
margin = self.__autoScrollMargin
viewrect = self.contentsRect()
rect = viewrect.adjusted(margin, margin, -margin, -margin)
# only do auto scroll when on the viewport's margins
return not rect.contains(pos) and viewrect.contains(pos)
else:
return False
def __startAutoScroll(self):
self.__autoScrollTimer.start(10)
log.debug("Auto scroll timer started")
def __stopAutoScroll(self):
if self.__autoScrollTimer.isActive():
self.__autoScrollTimer.stop()
log.debug("Auto scroll timer stopped")
def __autoScrollAdvance(self):
"""Advance the auto scroll
"""
pos = QCursor.pos()
pos = self.mapFromGlobal(pos)
margin = self.__autoScrollMargin
vvalue = self.verticalScrollBar().value()
hvalue = self.horizontalScrollBar().value()
vrect = QRect(0, 0, self.width(), self.height())
# What should be the speed
advance = 10
# We only do auto scroll if the mouse is inside the view.
if vrect.contains(pos):
if pos.x() < vrect.left() + margin:
self.horizontalScrollBar().setValue(hvalue - advance)
if pos.y() < vrect.top() + margin:
self.verticalScrollBar().setValue(vvalue - advance)
if pos.x() > vrect.right() - margin:
self.horizontalScrollBar().setValue(hvalue + advance)
if pos.y() > vrect.bottom() - margin:
self.verticalScrollBar().setValue(vvalue + advance)
if self.verticalScrollBar().value() == vvalue and \
self.horizontalScrollBar().value() == hvalue:
self.__stopAutoScroll()
else:
self.__stopAutoScroll()
log.debug("Auto scroll advance")
def setBackgroundIcon(self, icon):
if not isinstance(icon, QIcon):
raise TypeError("A QIcon expected.")
if self.__backgroundIcon != icon:
self.__backgroundIcon = icon
self.viewport().update()
def backgroundIcon(self):
return QIcon(self.__backgroundIcon)
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(
vrect.size().toSize().boundedTo(QSize(200, 200))
)
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
class WidgetManager(QObject):
"""
OWWidget instance manager class.
This class handles the lifetime of OWWidget instances in a
:class:`WidgetsScheme`.
"""
#: A new OWWidget was created and added by the manager.
widget_for_node_added = Signal(SchemeNode, QWidget)
#: An OWWidget was removed, hidden and will be deleted when appropriate.
widget_for_node_removed = Signal(SchemeNode, QWidget)
class ProcessingState(enum.IntEnum):
"""Widget processing state flags"""
#: Signal manager is updating/setting the widget's inputs
InputUpdate = 1
#: Widget has entered a blocking state (OWWidget.isBlocking)
BlockingUpdate = 2
#: Widget has entered processing state
ProcessingUpdate = 4
#: Widget is still in the process of initialization
Initializing = 8
InputUpdate, BlockingUpdate, ProcessingUpdate, Initializing = ProcessingState
#: Widget initialization states
Delayed = namedtuple(
"Delayed", ["node"])
PartiallyInitialized = namedtuple(
"Materializing",
["node", "partially_initialized_widget"])
Materialized = namedtuple(
"Materialized",
["node", "widget"])
class CreationPolicy(enum.Enum):
"""Widget Creation Policy"""
#: Widgets are scheduled to be created from the event loop, or when
#: first accessed with `widget_for_node`
Normal = "Normal"
#: Widgets are created immediately when added to the workflow model
Immediate = "Immediate"
#: Widgets are created only when first accessed with `widget_for_node`
OnDemand = "OnDemand"
Normal, Immediate, OnDemand = CreationPolicy
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__scheme = None
self.__signal_manager = None
self.__widgets = []
self.__initstate_for_node = {}
self.__creation_policy = WidgetManager.Normal
#: a queue of all nodes whose widgets are scheduled for
#: creation/initialization
self.__init_queue = deque() # type: Deque[SchemeNode]
#: Timer for scheduling widget initialization
self.__init_timer = QTimer(self, interval=0, singleShot=True)
self.__init_timer.timeout.connect(self.__create_delayed)
#: A mapping of SchemeNode -> OWWidget (note: a mapping is only added
#: after the widget is actually created)
self.__widget_for_node = {}
#: a mapping of OWWidget -> SchemeNode
self.__node_for_widget = {}
# Widgets that were 'removed' from the scheme but were at
# the time in an input update loop and could not be deleted
# immediately
self.__delay_delete = set()
#: Deleted/removed during creation/initialization.
self.__delete_after_create = []
#: processing state flags for all widgets (including the ones
#: in __delay_delete).
#: Note: widgets which have not yet been created do not have an entry
self.__widget_processing_state = {}
# Tracks the widget in the update loop by the SignalManager
self.__updating_widget = None
def set_scheme(self, scheme):
"""
Set the :class:`WidgetsScheme` instance to manage.
"""
self.__scheme = scheme
self.__signal_manager = scheme.findChild(SignalManager)
self.__signal_manager.processingStarted[SchemeNode].connect(
self.__on_processing_started
)
self.__signal_manager.processingFinished[SchemeNode].connect(
self.__on_processing_finished
)
scheme.node_added.connect(self.add_widget_for_node)
scheme.node_removed.connect(self.remove_widget_for_node)
scheme.runtime_env_changed.connect(self.__on_env_changed)
scheme.installEventFilter(self)
def scheme(self):
"""
Return the scheme instance on which this manager is installed.
"""
return self.__scheme
def signal_manager(self):
"""
Return the signal manager in use on the :func:`scheme`.
"""
return self.__signal_manager
def widget_for_node(self, node):
"""
Return the OWWidget instance for the scheme node.
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Delayed):
# Create the widget now if it is still pending
state = self.__materialize(state)
return state.widget
elif isinstance(state, WidgetManager.PartiallyInitialized):
widget = state.partially_initialized_widget
log.warning("WidgetManager.widget_for_node: "
"Accessing a partially created widget instance. "
"This is most likely a result of explicit "
"QApplication.processEvents call from the '%s.%s' "
"widgets __init__.",
type(widget).__module__, type(widget).__name__)
return widget
elif isinstance(state, WidgetManager.Materialized):
return state.widget
else:
assert False
def node_for_widget(self, widget):
"""
Return the SchemeNode instance for the OWWidget.
Raise a KeyError if the widget does not map to a node in the scheme.
"""
return self.__node_for_widget[widget]
def widget_properties(self, node):
"""
Return the current widget properties/settings.
Parameters
----------
node : SchemeNode
Returns
-------
settings : dict
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Materialized):
return state.widget.settingsHandler.pack_data(state.widget)
else:
return node.properties
def set_creation_policy(self, policy):
"""
Set the widget creation policy
Parameters
----------
policy : WidgetManager.CreationPolicy
"""
if self.__creation_policy != policy:
self.__creation_policy = policy
if self.__creation_policy == WidgetManager.Immediate:
self.__init_timer.stop()
while self.__init_queue:
state = self.__init_queue.popleft()
self.__materialize(state)
elif self.__creation_policy == WidgetManager.Normal:
if not self.__init_timer.isActive() and self.__init_queue:
self.__init_timer.start()
elif self.__creation_policy == WidgetManager.OnDemand:
self.__init_timer.stop()
else:
assert False
def creation_policy(self):
"""
Return the current widget creation policy
Returns
-------
policy: WidgetManager.CreationPolicy
"""
return self.__creation_policy
def add_widget_for_node(self, node):
"""
Create a new OWWidget instance for the corresponding scheme node.
"""
state = WidgetManager.Delayed(node)
self.__initstate_for_node[node] = state
if self.__creation_policy == WidgetManager.Immediate:
self.__initstate_for_node[node] = self.__materialize(state)
elif self.__creation_policy == WidgetManager.Normal:
self.__init_queue.append(state)
if not self.__init_timer.isActive():
self.__init_timer.start()
elif self.__creation_policy == WidgetManager.OnDemand:
self.__init_queue.append(state)
def __materialize(self, state):
# Create and initialize an OWWidget for a Delayed
# widget initialization
assert isinstance(state, WidgetManager.Delayed)
if state in self.__init_queue:
self.__init_queue.remove(state)
node = state.node
widget = self.create_widget_instance(node)
self.__widgets.append(widget)
self.__widget_for_node[node] = widget
self.__node_for_widget[widget] = node
self.__initialize_widget_state(node, widget)
state = WidgetManager.Materialized(node, widget)
self.__initstate_for_node[node] = state
self.widget_for_node_added.emit(node, widget)
return state
def remove_widget_for_node(self, node):
"""
Remove the OWWidget instance for node.
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Delayed):
del self.__initstate_for_node[node]
self.__init_queue.remove(state)
elif isinstance(state, WidgetManager.Materialized):
# Update the node's stored settings/properties dict before
# removing the widget.
# TODO: Update/sync whenever the widget settings change.
node.properties = self._widget_settings(state.widget)
self.__widgets.remove(state.widget)
del self.__initstate_for_node[node]
del self.__widget_for_node[node]
del self.__node_for_widget[state.widget]
node.title_changed.disconnect(state.widget.setCaption)
state.widget.progressBarValueChanged.disconnect(node.set_progress)
self.widget_for_node_removed.emit(node, state.widget)
self._delete_widget(state.widget)
elif isinstance(state, WidgetManager.PartiallyInitialized):
widget = state.partially_initialized_widget
raise RuntimeError(
"A widget/node {} was removed while being initialized. "
"This is most likely a result of an explicit "
"QApplication.processEvents call from the '{}.{}' "
"widgets __init__.\n"
.format(state.node.title, type(widget).__module__,
type(widget).__init__))
def _widget_settings(self, widget):
return widget.settingsHandler.pack_data(widget)
def _delete_widget(self, widget):
"""
Delete the OWBaseWidget instance.
"""
widget.close()
# Save settings to user global settings.
widget.saveSettings()
# Notify the widget it will be deleted.
widget.onDeleteWidget()
if self.__widget_processing_state[widget] != 0:
# If the widget is in an update loop and/or blocking we
# delay the scheduled deletion until the widget is done.
self.__delay_delete.add(widget)
else:
widget.deleteLater()
del self.__widget_processing_state[widget]
def create_widget_instance(self, node):
"""
Create a OWWidget instance for the node.
"""
desc = node.description
klass = widget = None
initialized = False
error = None
# First try to actually retrieve the class.
try:
klass = name_lookup(desc.qualified_name)
except (ImportError, AttributeError):
sys.excepthook(*sys.exc_info())
error = "Could not import {0!r}\n\n{1}".format(
node.description.qualified_name, traceback.format_exc()
)
except Exception:
sys.excepthook(*sys.exc_info())
error = "An unexpected error during import of {0!r}\n\n{1}".format(
node.description.qualified_name, traceback.format_exc()
)
if klass is None:
widget = mock_error_owwidget(node, error)
initialized = True
if widget is None:
log.info("WidgetManager: Creating '%s.%s' instance '%s'.",
klass.__module__, klass.__name__, node.title)
widget = klass.__new__(
klass,
None,
captionTitle=node.title,
signal_manager=self.signal_manager(),
stored_settings=node.properties,
# NOTE: env is a view of the real env and reflects
# changes to the environment.
env=self.scheme().runtime_env()
)
initialized = False
# Init the node/widget mapping and state before calling __init__
# Some OWWidgets might already send data in the constructor
# (should this be forbidden? Raise a warning?) triggering the signal
# manager which would request the widget => node mapping or state
# Furthermore they can (though they REALLY REALLY REALLY should not)
# explicitly call qApp.processEvents.
assert node not in self.__widget_for_node
self.__widget_for_node[node] = widget
self.__node_for_widget[widget] = node
self.__widget_processing_state[widget] = WidgetManager.Initializing
self.__initstate_for_node[node] = \
WidgetManager.PartiallyInitialized(node, widget)
if not initialized:
try:
widget.__init__()
except Exception:
sys.excepthook(*sys.exc_info())
msg = traceback.format_exc()
msg = "Could not create {0!r}\n\n{1}".format(
node.description.name, msg
)
# remove state tracking for widget ...
del self.__widget_for_node[node]
del self.__node_for_widget[widget]
del self.__widget_processing_state[widget]
# ... and substitute it with a mock error widget.
widget = mock_error_owwidget(node, msg)
self.__widget_for_node[node] = widget
self.__node_for_widget[widget] = node
self.__widget_processing_state[widget] = 0
self.__initstate_for_node[node] = \
WidgetManager.Materialized(node, widget)
self.__initstate_for_node[node] = \
WidgetManager.Materialized(node, widget)
# Clear Initializing flag
self.__widget_processing_state[widget] &= ~WidgetManager.Initializing
node.title_changed.connect(widget.setCaption)
# Widget's info/warning/error messages.
widget.messageActivated.connect(self.__on_widget_state_changed)
widget.messageDeactivated.connect(self.__on_widget_state_changed)
# Widget's statusTip
node.set_status_message(widget.statusMessage())
widget.statusMessageChanged.connect(node.set_status_message)
# Widget's progress bar value state.
widget.progressBarValueChanged.connect(node.set_progress)
# Widget processing state (progressBarInit/Finished)
# and the blocking state.
widget.processingStateChanged.connect(
self.__on_processing_state_changed
)
widget.blockingStateChanged.connect(self.__on_blocking_state_changed)
if widget.isBlocking():
# A widget can already enter blocking state in __init__
self.__widget_processing_state[widget] |= self.BlockingUpdate
if widget.processingState != 0:
# It can also start processing (initialization of resources, ...)
self.__widget_processing_state[widget] |= self.ProcessingUpdate
node.set_processing_state(1)
node.set_progress(widget.progressBarValue)
# Install a help shortcut on the widget
help_shortcut = QShortcut(QKeySequence("F1"), widget)
help_shortcut.activated.connect(self.__on_help_request)
# Up shortcut (activate/open parent)
up_shortcut = QShortcut(
QKeySequence(Qt.ControlModifier + Qt.Key_Up), widget)
up_shortcut.activated.connect(self.__on_activate_parent)
# Call setters only after initialization.
widget.setWindowIcon(
icon_loader.from_description(desc).get(desc.icon)
)
widget.setCaption(node.title)
# Schedule an update with the signal manager, due to the cleared
# implicit Initializing flag
self.signal_manager()._update()
return widget
def node_processing_state(self, node):
"""
Return the processing state flags for the node.
Same as `manager.widget_processing_state(manger.widget_for_node(node))`
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Materialized):
return self.__widget_processing_state[state.widget]
elif isinstance(state, WidgetManager.PartiallyInitialized):
return self.__widget_processing_state[state.partially_initialized_widget]
else:
return WidgetManager.Initializing
def widget_processing_state(self, widget):
"""
Return the processing state flags for the widget.
The state is an bitwise or of `InputUpdate` and `BlockingUpdate`.
"""
return self.__widget_processing_state[widget]
def __create_delayed(self):
if self.__init_queue:
state = self.__init_queue.popleft()
node = state.node
self.__initstate_for_node[node] = self.__materialize(state)
if self.__creation_policy == WidgetManager.Normal and \
self.__init_queue:
# restart the timer if pending widgets still in the queue
self.__init_timer.start()
def eventFilter(self, receiver, event):
if event.type() == QEvent.Close and receiver is self.__scheme:
self.signal_manager().stop()
# Notify the widget instances.
for widget in list(self.__widget_for_node.values()):
widget.close()
widget.saveSettings()
widget.onDeleteWidget()
event.accept()
return True
return QObject.eventFilter(self, receiver, event)
def __on_help_request(self):
"""
Help shortcut was pressed. We send a `QWhatsThisClickedEvent` to
the scheme and hope someone responds to it.
"""
# Sender is the QShortcut, and parent the OWBaseWidget
widget = self.sender().parent()
try:
node = self.node_for_widget(widget)
except KeyError:
pass
else:
qualified_name = node.description.qualified_name
help_url = "help://search?" + urlencode({"id": qualified_name})
event = QWhatsThisClickedEvent(help_url)
QCoreApplication.sendEvent(self.scheme(), event)
def __on_activate_parent(self):
"""
Activate parent shortcut was pressed.
"""
event = ActivateParentEvent()
QCoreApplication.sendEvent(self.scheme(), event)
def __initialize_widget_state(self, node, widget):
"""
Initialize the tracked info/warning/error message state.
"""
for message_group in widget.message_groups:
message = user_message_from_state(message_group)
if message:
node.set_state_message(message)
def __on_widget_state_changed(self, msg):
"""
The OWBaseWidget info/warning/error state has changed.
"""
widget = msg.group.widget
try:
node = self.node_for_widget(widget)
except KeyError:
pass
else:
self.__initialize_widget_state(node, widget)
def __on_processing_state_changed(self, state):
"""
A widget processing state has changed (progressBarInit/Finished)
"""
widget = self.sender()
try:
node = self.node_for_widget(widget)
except KeyError:
return
if state:
self.__widget_processing_state[widget] |= self.ProcessingUpdate
else:
self.__widget_processing_state[widget] &= ~self.ProcessingUpdate
self.__update_node_processing_state(node)
def __on_processing_started(self, node):
"""
Signal manager entered the input update loop for the node.
"""
widget = self.widget_for_node(node)
# Remember the widget instance. The node and the node->widget mapping
# can be removed between this and __on_processing_finished.
self.__updating_widget = widget
self.__widget_processing_state[widget] |= self.InputUpdate
self.__update_node_processing_state(node)
def __on_processing_finished(self, node):
"""
Signal manager exited the input update loop for the node.
"""
widget = self.__updating_widget
self.__widget_processing_state[widget] &= ~self.InputUpdate
if widget in self.__node_for_widget:
self.__update_node_processing_state(node)
elif widget in self.__delay_delete:
self.__try_delete(widget)
else:
raise ValueError("%r is not managed" % widget)
self.__updating_widget = None
def __on_blocking_state_changed(self, state):
"""
OWWidget blocking state has changed.
"""
if not state:
# schedule an update pass.
self.signal_manager()._update()
widget = self.sender()
if state:
self.__widget_processing_state[widget] |= self.BlockingUpdate
else:
self.__widget_processing_state[widget] &= ~self.BlockingUpdate
if widget in self.__node_for_widget:
node = self.node_for_widget(widget)
self.__update_node_processing_state(node)
elif widget in self.__delay_delete:
self.__try_delete(widget)
def __update_node_processing_state(self, node):
"""
Update the `node.processing_state` to reflect the widget state.
"""
state = self.node_processing_state(node)
node.set_processing_state(1 if state else 0)
def __try_delete(self, widget):
if self.__widget_processing_state[widget] == 0:
self.__delay_delete.remove(widget)
widget.deleteLater()
del self.__widget_processing_state[widget]
def __on_env_changed(self, key, newvalue, oldvalue):
# Notify widgets of a runtime environment change
for widget in self.__widget_for_node.values():
widget.workflowEnvChanged(key, newvalue, oldvalue)
class SignalManager(QObject):
"""
SignalManager handles the runtime signal propagation for a :class:`.Scheme`
instance.
Note
----
If a scheme instance is passed as a parent to the constructor it is also
set as the workflow model.
"""
class State(enum.IntEnum):
"""
SignalManager state flags.
.. seealso:: :func:`SignalManager.state()`
"""
#: The manager is running, i.e. it propagates signals
Running = 0
#: The manager is stopped. It does not track node output changes,
#: and does not deliver signals to dependent nodes
Stopped = 1
#: The manager is paused. It still tracks node output changes, but
#: does not deliver new signals to dependent nodes. The pending signals
#: will be delivered once it enters Running state again
Paused = 2
#: The manager is running, i.e. it propagates signals
Running = State.Running
#: The manager is stopped. It does not track node ouput changes,
#: and does not deliver signals to dependent nodes
Stopped = State.Stopped
#: The manager is paused. It still tracks node output changes, but
#: does not deliver new signals to dependent nodes. The pending signals
#: will be delivered once it enters Running state again
Paused = State.Paused
# unused; back-compatibility
Error = 3
class RuntimeState(enum.IntEnum):
"""
SignalManager runtime state.
See Also
--------
SignalManager.runtime_state
"""
#: Waiting, idle state. The signal queue is empty
Waiting = 0
#: ...
Processing = 1
Waiting = RuntimeState.Waiting
Processing = RuntimeState.Processing
#: Emitted when the state of the signal manager changes.
stateChanged = pyqtSignal(int)
#: Emitted when signals are added to the queue.
updatesPending = pyqtSignal()
#: Emitted right before a `SchemeNode` instance has its inputs updated.
processingStarted = pyqtSignal([], [SchemeNode])
#: Emitted right after a `SchemeNode` instance has had its inputs updated.
processingFinished = pyqtSignal([], [SchemeNode])
#: Emitted when `SignalManager`'s runtime state changes.
runtimeStateChanged = pyqtSignal(int)
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.__workflow = None # type: Optional[Scheme]
self.__input_queue = [] # type: List[Signal]
# mapping a node to its current outputs
self.__node_outputs = {
} # type: Dict[SchemeNode, Dict[OutputSignal, Dict[Any, Any]]]
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
if isinstance(parent, Scheme):
self.set_workflow(parent)
def _can_process(self): # type: () -> bool
"""
Return a bool indicating if the manger can enter the main
processing loop.
"""
return self.__state not in [SignalManager.Error, SignalManager.Stopped]
def workflow(self):
# type: () -> Optional[Scheme]
"""
Return the :class:`Scheme` instance.
"""
return self.__workflow
#: Alias
scheme = workflow
def set_workflow(self, workflow):
# type: (Scheme) -> None
"""
Set the workflow model.
Parameters
----------
workflow : Scheme
"""
if workflow is self.__workflow:
return
if self.__workflow is not None:
for link in self.__workflow.links:
link.enabled_changed.disconnect(self.__on_link_enabled_changed)
self.__workflow.node_added.disconnect(self.__on_node_added)
self.__workflow.node_removed.disconnect(self.__on_node_removed)
self.__workflow.link_added.disconnect(self.__on_link_added)
self.__workflow.link_removed.disconnect(self.__on_link_removed)
self.__workflow.removeEventFilter(self)
self.__node_outputs = {}
self.__input_queue = []
self.__workflow = workflow
if workflow is not None:
workflow.node_added.connect(self.__on_node_added)
workflow.node_removed.connect(self.__on_node_removed)
workflow.link_added.connect(self.__on_link_added)
workflow.link_removed.connect(self.__on_link_removed)
for node in workflow.nodes:
self.__node_outputs[node] = defaultdict(dict)
for link in workflow.links:
link.enabled_changed.connect(self.__on_link_enabled_changed)
workflow.installEventFilter(self)
def has_pending(self): # type: () -> bool
"""
Does the manager have any signals to deliver?
"""
return bool(self.__input_queue)
def start(self): # type: () -> None
"""
Start the update loop.
Note
----
The updates will not happen until the control reaches the Qt event
loop.
"""
if self.__state != SignalManager.Running:
self.__state = SignalManager.Running
self.stateChanged.emit(SignalManager.Running)
self._update()
def stop(self): # type: () -> None
"""
Stop the update loop.
Note
----
If the `SignalManager` is currently in `process_queues` it will
still update all current pending signals, but will not re-enter
until `start()` is called again.
"""
if self.__state != SignalManager.Stopped:
self.__state = SignalManager.Stopped
self.stateChanged.emit(SignalManager.Stopped)
self.__update_timer.stop()
def pause(self): # type: () -> None
"""
Pause the delivery of signals.
"""
if self.__state != SignalManager.Paused:
self.__state = SignalManager.Paused
self.stateChanged.emit(SignalManager.Paused)
self.__update_timer.stop()
def resume(self):
# type: () -> None
"""
Resume the delivery of signals.
"""
if self.__state == SignalManager.Paused:
self.__state = SignalManager.Running
self.stateChanged.emit(self.__state)
self._update()
def step(self):
# type: () -> None
"""
Deliver signals to a single node (only applicable while the `state()`
is `Paused`).
"""
if self.__state == SignalManager.Paused:
self.process_queued()
def state(self):
# type: () -> State
"""
Return the current state.
Return
------
state : SignalManager.State
"""
return self.__state
def _set_runtime_state(self, state):
# type: (RuntimeState) -> None
"""
Set the runtime state.
Should only be called by `SignalManager` implementations.
"""
if self.__runtime_state != state:
self.__runtime_state = state
self.runtimeStateChanged.emit(self.__runtime_state)
def runtime_state(self):
# type: () -> RuntimeState
"""
Return the runtime state. This can be `SignalManager.Waiting`
or `SignalManager.Processing`.
"""
return self.__runtime_state
def __on_node_removed(self, node):
# remove all pending input signals for node so we don't get
# stale references in process_node.
# NOTE: This does not remove output signals for this node. In
# particular the final 'None' will be delivered to the sink
# nodes even after the source node is no longer in the scheme.
log.info("Removing pending signals for '%s'.", node.title)
self.remove_pending_signals(node)
del self.__node_outputs[node]
def __on_node_added(self, node):
self.__node_outputs[node] = defaultdict(dict)
def __on_link_added(self, link):
# push all current source values to the sink
link.set_runtime_state(SchemeLink.Empty)
if link.enabled:
log.info("Scheduling signal data update for '%s'.", link)
self._schedule(self.signals_on_link(link))
self._update()
link.enabled_changed.connect(self.__on_link_enabled_changed)
def __on_link_removed(self, link):
# purge all values in sink's queue
log.info("Scheduling signal data purge (%s).", link)
self.purge_link(link)
link.enabled_changed.disconnect(self.__on_link_enabled_changed)
def __on_link_enabled_changed(self, enabled):
if enabled:
link = self.sender()
log.info("Link %s enabled. Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
def signals_on_link(self, link):
# type: (SchemeLink) -> List[Signal]
"""
Return :class:`Signal` instances representing the current values
present on the `link`.
"""
items = self.link_contents(link)
signals = []
for key, value in items.items():
signals.append(Signal(link, value, key))
return signals
def link_contents(self, link):
# type: (SchemeLink) -> Dict[Any, Any]
"""
Return the contents on the `link`.
"""
node, channel = link.source_node, link.source_channel
if node in self.__node_outputs:
return self.__node_outputs[node][channel]
else:
# if the the node was already removed its tracked outputs in
# __node_outputs are cleared, however the final 'None' signal
# deliveries for the link are left in the _input_queue.
pending = [sig for sig in self.__input_queue if sig.link is link]
return {sig.id: sig.value for sig in pending}
def send(self, node, channel, value, id):
# type: (SchemeNode, OutputSignal, Any, Any) -> None
"""
Send the `value` with `id` on an output `channel` from node.
Schedule the signal delivery to all dependent nodes
Parameters
----------
node : SchemeNode
The originating node.
channel : OutputSignal
The nodes output on which the value is sent.
value : Any
The value to send,
id : Any
Signal id.
"""
if self.__workflow is None:
raise RuntimeError("'send' called with no workflow!.")
log.debug("%r sending %r (id: %r) on channel %r", node.title,
type(value), id, channel.name)
scheme = self.__workflow
self.__node_outputs[node][channel][id] = value
links = filter(
is_enabled,
scheme.find_links(source_node=node, source_channel=channel))
signals = []
for link in links:
signals.append(Signal(link, value, id))
self._schedule(signals)
def purge_link(self, link):
# type: (SchemeLink) -> None
"""
Purge the link (send None for all ids currently present)
"""
contents = self.link_contents(link)
ids = contents.keys()
signals = [Signal(link, None, id) for id in ids]
self._schedule(signals)
def _schedule(self, signals):
# type: (List[Signal]) -> None
"""
Schedule a list of :class:`Signal` for delivery.
"""
self.__input_queue.extend(signals)
for link in {sig.link for sig in signals}:
# update the SchemeLink's runtime state flags
contents = self.link_contents(link)
if any(value is not None for value in contents.values()):
state = SchemeLink.Active
else:
state = SchemeLink.Empty
link.set_runtime_state(state | SchemeLink.Pending)
if signals:
self.updatesPending.emit()
self._update()
def _update_link(self, link):
# type: (SchemeLink) -> None
"""
Schedule update of a single link.
"""
signals = self.signals_on_link(link)
self._schedule(signals)
def process_queued(self, max_nodes=None):
# type: (Any) -> None
"""
Process queued signals.
Take one node node from the pending input queue and deliver
all scheduled signals.
"""
if not (max_nodes is None or max_nodes == 1):
warnings.warn(
"`max_nodes` is deprecated and will be removed in the future",
FutureWarning,
stacklevel=2)
if self.__runtime_state == SignalManager.Processing:
raise RuntimeError("Cannot re-enter 'process_queued'")
if not self._can_process():
raise RuntimeError("Can't process in state %i" % self.__state)
log.info("SignalManager: Processing queued signals")
node_update_front = self.node_update_front()
log.debug("SignalManager: Nodes eligible for update %s",
[node.title for node in node_update_front])
if node_update_front:
self.process_node(node_update_front[0])
def process_node(self, node):
# type: (SchemeNode) -> None
"""
Process pending input signals for `node`.
"""
assert self.__runtime_state != SignalManager.Processing
signals_in = self.pending_input_signals(node)
self.remove_pending_signals(node)
signals_in = self.compress_signals(signals_in)
log.debug("Processing %r, sending %i signals.", node.title,
len(signals_in))
# Clear the link's pending flag.
for link in {sig.link for sig in signals_in}:
link.set_runtime_state(link.runtime_state() & ~SchemeLink.Pending)
def process_dynamic(signals):
# type: (List[Signal]) -> List[Signal]
"""
Process dynamic signals; Update the link's dynamic_enabled flag if
the value is valid; replace values that do not type check with
`None`
"""
res = []
for sig in signals:
# Check and update the dynamic link state
link = sig.link
if sig.link.is_dynamic():
enabled = can_enable_dynamic(link, sig.value)
link.set_dynamic_enabled(enabled)
if not enabled:
# Send None instead (clear the link)
sig = Signal(link, None, sig.id)
res.append(sig)
return res
signals_in = process_dynamic(signals_in)
assert ({sig.link
for sig in self.__input_queue
}.intersection({sig.link
for sig in signals_in}) == set([]))
self._set_runtime_state(SignalManager.Processing)
self.processingStarted.emit()
self.processingStarted[SchemeNode].emit(node)
try:
self.send_to_node(node, signals_in)
finally:
self.processingFinished.emit()
self.processingFinished[SchemeNode].emit(node)
self._set_runtime_state(SignalManager.Waiting)
def compress_signals(self, signals):
# type: (List[Signal]) -> List[Signal]
"""
Compress a list of :class:`Signal` instances to be delivered.
Before the signal values are delivered to the sink node they can be
optionally `compressed`, i.e. values can be merged or dropped
depending on the execution semantics.
The input list is in the order that the signals were enqueued.
The base implementation returns the list unmodified.
Parameters
----------
signals : List[Signal]
Return
------
signals : List[Signal]
"""
return signals
def send_to_node(self, node, signals):
# type: (SchemeNode, List[Signal]) -> None
"""
Abstract. Reimplement in subclass.
Send/notify the `node` instance (or whatever object/instance it is a
representation of) that it has new inputs as represented by the
`signals` list).
Parameters
----------
node : SchemeNode
signals : List[Signal]
"""
raise NotImplementedError
def is_pending(self, node):
# type: (SchemeNode) -> bool
"""
Is `node` (class:`SchemeNode`) scheduled for processing (i.e.
it has incoming pending signals).
Parameters
----------
node : SchemeNode
Returns
-------
pending : bool
"""
return node in [signal.link.sink_node for signal in self.__input_queue]
def pending_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of pending nodes.
The nodes are returned in the order they were enqueued for
signal delivery.
Returns
-------
nodes : List[SchemeNode]
"""
return list(unique(sig.link.sink_node for sig in self.__input_queue))
def pending_input_signals(self, node):
# type: (SchemeNode) -> List[Signal]
"""
Return a list of pending input signals for node.
"""
return [
signal for signal in self.__input_queue
if node is signal.link.sink_node
]
def remove_pending_signals(self, node):
# type: (SchemeNode) -> None
"""
Remove pending signals for `node`.
"""
for signal in self.pending_input_signals(node):
try:
self.__input_queue.remove(signal)
except ValueError:
pass
def blocking_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of nodes in a blocking state.
"""
workflow = self.__workflow
if workflow is None:
return []
else:
return [node for node in workflow.nodes if self.is_blocking(node)]
def is_blocking(self, node):
# type: (SchemeNode) -> bool
"""
Is the node in `blocking` state.
Is it currently in a state where will produce new outputs and
therefore no signals should be delivered to dependent nodes until
it does so.
The default implementation returns False.
"""
# TODO: this needs a different name
return False
def node_update_front(self):
# type: () -> List[SchemeNode]
"""
Return a list of nodes on the update front, i.e. nodes scheduled for
an update that have no ancestor which is either itself scheduled
for update or is in a blocking state).
Note
----
The node's ancestors are only computed over enabled links.
"""
scheme = self.__workflow
if scheme is None:
return []
def expand(node):
return [
link.sink_node for link in scheme.find_links(source_node=node)
if link.enabled
]
components = strongly_connected_components(scheme.nodes, expand)
node_scc = {node: scc for scc in components for node in scc}
def isincycle(node):
# type: (SchemeNode) -> bool
return len(node_scc[node]) > 1
# a list of all nodes currently active/executing a task.
blocking_nodes = set(self.blocking_nodes())
dependents = partial(dependent_nodes, scheme)
blocked_nodes = reduce(set.union, map(dependents, blocking_nodes),
set(blocking_nodes))
pending = self.pending_nodes()
pending_downstream = set()
for n in pending:
depend = set(dependents(n))
if isincycle(n):
# a pending node in a cycle would would have a circular
# dependency on itself, preventing any progress being made
# by the workflow execution.
cc = node_scc[n]
depend -= set(cc)
pending_downstream.update(depend)
log.debug("Pending nodes: %s", pending)
log.debug("Blocking nodes: %s", blocking_nodes)
noneligible = pending_downstream | blocked_nodes
return [node for node in pending if node not in noneligible]
@Slot()
def __process_next(self):
if not self.__state == SignalManager.Running:
log.debug("Received 'UpdateRequest' while not in 'Running' state")
return
if self.__runtime_state == SignalManager.Processing:
# This happens if QCoreApplication.processEvents is called from
# the input handlers. A `__process_next` must be rescheduled when
# exiting process_queued.
log.warning("Received 'UpdateRequest' while in 'process_queued'. "
"An update will be re-scheduled when exiting the "
"current update.")
return
nbusy = len(self.blocking_nodes())
log.info(
"'UpdateRequest' event, queued signals: %i, nbusy: %i "
"(MAX_CONCURRENT: %i)", len(self.__input_queue), nbusy,
MAX_CONCURRENT)
if self.__input_queue and nbusy < MAX_CONCURRENT:
try:
self.process_queued()
finally:
# Schedule another update (will be a noop if nothing to do).
if self.__input_queue and self.__state == SignalManager.Running:
self.__update_timer.start()
def _update(self): # type: () -> None
"""
Schedule processing at a later time.
"""
if self.__state == SignalManager.Running and \
not self.__update_timer.isActive():
self.__update_timer.start()
def eventFilter(self, receiver, event):
"""
Reimplemented.
"""
if event.type() == QEvent.DeferredDelete \
and receiver is self.__workflow:
# ?? This is really, probably, mostly, likely not needed. Should
# just raise error from __process_next.
state = self.runtime_state()
if state == SignalManager.Processing:
log.critical(
"The workflow model %r received a deferred delete request "
"while performing an input update. "
"Deferring a 'DeferredDelete' event for the workflow "
"until SignalManager exits the current update step.",
self.__workflow)
warnings.warn(
"The workflow model received a deferred delete request "
"while updating inputs. In the future this will raise "
"a RuntimeError",
_FutureRuntimeWarning,
)
event.setAccepted(False)
self.processingFinished.connect(self.__workflow.deleteLater)
self.stop()
return True
return super().eventFilter(receiver, event)
class CanvasView(QGraphicsView):
"""Canvas View handles the zooming.
"""
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.__backgroundIcon = QIcon()
self.__autoScroll = False
self.__autoScrollMargin = 16
self.__autoScrollTimer = QTimer(self)
self.__autoScrollTimer.timeout.connect(self.__autoScrollAdvance)
self.__scale = 10
def setScene(self, scene):
QGraphicsView.setScene(self, scene)
self._ensureSceneRect(scene)
def _ensureSceneRect(self, scene):
r = scene.addRect(QRectF(0, 0, 400, 400))
scene.sceneRect()
scene.removeItem(r)
def setAutoScrollMargin(self, margin):
self.__autoScrollMargin = margin
def autoScrollMargin(self):
return self.__autoScrollMargin
def setAutoScroll(self, enable):
self.__autoScroll = enable
def autoScroll(self):
return self.__autoScroll
def mousePressEvent(self, event):
QGraphicsView.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
if not self.__autoScrollTimer.isActive(
) and self.__shouldAutoScroll(event.pos()):
self.__startAutoScroll()
QGraphicsView.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if event.button() & Qt.LeftButton:
self.__stopAutoScroll()
return QGraphicsView.mouseReleaseEvent(self, event)
def reset_zoom(self):
self.__set_zoom(10)
def change_zoom(self, delta):
self.__set_zoom(self.__scale + delta)
def __set_zoom(self, scale):
self.__scale = min(15, max(scale, 3))
transform = QTransform()
transform.scale(self.__scale / 10, self.__scale / 10)
self.setTransform(transform)
def wheelEvent(self, event: QWheelEvent):
# use mouse position as anchor while zooming
self.setTransformationAnchor(2)
if event.modifiers() & Qt.ControlModifier and event.buttons(
) == Qt.NoButton:
delta = event.angleDelta().y()
if (QT_VERSION >= 0x050500
and event.source() != Qt.MouseEventNotSynthesized
and abs(delta) < 50):
self.change_zoom(delta / 10)
else:
self.change_zoom(copysign(1, delta))
else:
super().wheelEvent(event)
def __shouldAutoScroll(self, pos):
if self.__autoScroll:
margin = self.__autoScrollMargin
viewrect = self.contentsRect()
rect = viewrect.adjusted(margin, margin, -margin, -margin)
# only do auto scroll when on the viewport's margins
return not rect.contains(pos) and viewrect.contains(pos)
else:
return False
def __startAutoScroll(self):
self.__autoScrollTimer.start(10)
log.debug("Auto scroll timer started")
def __stopAutoScroll(self):
if self.__autoScrollTimer.isActive():
self.__autoScrollTimer.stop()
log.debug("Auto scroll timer stopped")
def __autoScrollAdvance(self):
"""Advance the auto scroll
"""
pos = QCursor.pos()
pos = self.mapFromGlobal(pos)
margin = self.__autoScrollMargin
vvalue = self.verticalScrollBar().value()
hvalue = self.horizontalScrollBar().value()
vrect = QRect(0, 0, self.width(), self.height())
# What should be the speed
advance = 10
# We only do auto scroll if the mouse is inside the view.
if vrect.contains(pos):
if pos.x() < vrect.left() + margin:
self.horizontalScrollBar().setValue(hvalue - advance)
if pos.y() < vrect.top() + margin:
self.verticalScrollBar().setValue(vvalue - advance)
if pos.x() > vrect.right() - margin:
self.horizontalScrollBar().setValue(hvalue + advance)
if pos.y() > vrect.bottom() - margin:
self.verticalScrollBar().setValue(vvalue + advance)
if (self.verticalScrollBar().value() == vvalue
and self.horizontalScrollBar().value() == hvalue):
self.__stopAutoScroll()
else:
self.__stopAutoScroll()
log.debug("Auto scroll advance")
def setBackgroundIcon(self, icon):
if not isinstance(icon, QIcon):
raise TypeError("A QIcon expected.")
if self.__backgroundIcon != icon:
self.__backgroundIcon = icon
self.viewport().update()
def backgroundIcon(self):
return QIcon(self.__backgroundIcon)
def drawBackground(self, painter, rect):
QGraphicsView.drawBackground(self, painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
class SignalManager(QObject):
"""
Handle all runtime signal propagation for a :clas:`Scheme` instance.
The scheme must be passed to the constructor and will become the parent
of this object. Furthermore this should happen before any items
(nodes, links) are added to the scheme.
"""
Running, Stoped, Paused, Error = range(4)
"""SignalManger state flags."""
Waiting, Processing = range(2)
"""SignalManager runtime state flags."""
stateChanged = Signal(int)
"""Emitted when the state of the signal manager changes."""
updatesPending = Signal()
"""Emitted when signals are added to the queue."""
processingStarted = Signal([], [SchemeNode])
"""Emitted right before a `SchemeNode` instance has its inputs
updated.
"""
processingFinished = Signal([], [SchemeNode])
"""Emitted right after a `SchemeNode` instance has had its inputs
updated.
"""
runtimeStateChanged = Signal(int)
"""Emitted when `SignalManager`'s runtime state changes."""
def __init__(self, scheme):
assert(scheme)
QObject.__init__(self, scheme)
self._input_queue = []
# mapping a node to it's current outputs
# {node: {channel: {id: signal_value}}}
self._node_outputs = {}
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
# A flag indicating if UpdateRequest event should be rescheduled
self.__reschedule = False
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
def _can_process(self):
"""
Return a bool indicating if the manger can enter the main
processing loop.
"""
return self.__state not in [SignalManager.Error, SignalManager.Stoped]
def scheme(self):
"""
Return the parent class:`Scheme` instance.
"""
return self.parent()
def start(self):
"""
Start the update loop.
.. note:: The updates will not happen until the control reaches
the Qt event loop.
"""
if self.__state != SignalManager.Running:
self.__state = SignalManager.Running
self.stateChanged.emit(SignalManager.Running)
self._update()
def stop(self):
"""
Stop the update loop.
.. note:: If the `SignalManager` is currently in `process_queues` it
will still update all current pending signals, but will not
re-enter until `start()` is called again
"""
if self.__state != SignalManager.Stoped:
self.__state = SignalManager.Stoped
self.stateChanged.emit(SignalManager.Stoped)
self.__update_timer.stop()
def pause(self):
"""
Pause the updates.
"""
if self.__state != SignalManager.Paused:
self.__state = SignalManager.Paused
self.stateChanged.emit(SignalManager.Paused)
self.__update_timer.stop()
def resume(self):
if self.__state == SignalManager.Paused:
self.__state = SignalManager.Running
self.stateChanged.emit(self.__state)
self._update()
def step(self):
if self.__state == SignalManager.Paused:
self.process_queued()
def state(self):
"""
Return the current state.
"""
return self.__state
def _set_runtime_state(self, state):
"""
Set the runtime state.
Should only be called by `SignalManager` implementations.
"""
if self.__runtime_state != state:
self.__runtime_state = state
self.runtimeStateChanged.emit(self.__runtime_state)
def runtime_state(self):
"""
Return the runtime state. This can be `SignalManager.Waiting`
or `SignalManager.Processing`.
"""
return self.__runtime_state
def on_node_removed(self, node):
# remove all pending input signals for node so we don't get
# stale references in process_node.
# NOTE: This does not remove output signals for this node. In
# particular the final 'None' will be delivered to the sink
# nodes even after the source node is no longer in the scheme.
log.info("Node %r removed. Removing pending signals.",
node.title)
self.remove_pending_signals(node)
del self._node_outputs[node]
def on_node_added(self, node):
self._node_outputs[node] = defaultdict(dict)
def link_added(self, link):
# push all current source values to the sink
link.set_runtime_state(SchemeLink.Empty)
if link.enabled:
log.info("Link added (%s). Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
self._update()
link.enabled_changed.connect(self.link_enabled_changed)
def link_removed(self, link):
# purge all values in sink's queue
log.info("Link removed (%s). Scheduling signal data purge.", link)
self.purge_link(link)
link.enabled_changed.disconnect(self.link_enabled_changed)
def link_enabled_changed(self, enabled):
if enabled:
link = self.sender()
log.info("Link %s enabled. Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
def signals_on_link(self, link):
"""
Return _Signal instances representing the current values
present on the link.
"""
items = self.link_contents(link)
signals = []
for key, value in items.items():
signals.append(_Signal(link, value, key))
return signals
def link_contents(self, link):
"""
Return the contents on link.
"""
node, channel = link.source_node, link.source_channel
if node in self._node_outputs:
return self._node_outputs[node][channel]
else:
# if the the node was already removed it's tracked outputs in
# _node_outputs are cleared, however the final 'None' signal
# deliveries for the link are left in the _input_queue.
pending = [sig for sig in self._input_queue
if sig.link is link]
return {sig.id: sig.value for sig in pending}
def send(self, node, channel, value, id):
"""
"""
log.debug("%r sending %r (id: %r) on channel %r",
node.title, type(value), id, channel.name)
scheme = self.scheme()
self._node_outputs[node][channel][id] = value
links = scheme.find_links(source_node=node, source_channel=channel)
links = filter(is_enabled, links)
signals = []
for link in links:
signals.append(_Signal(link, value, id))
self._schedule(signals)
def purge_link(self, link):
"""
Purge the link (send None for all ids currently present)
"""
contents = self.link_contents(link)
ids = contents.keys()
signals = [_Signal(link, None, id) for id in ids]
self._schedule(signals)
def _schedule(self, signals):
"""
Schedule a list of :class:`_Signal` for delivery.
"""
self._input_queue.extend(signals)
for link in {sig.link for sig in signals}:
# update the SchemeLink's runtime state flags
contents = self.link_contents(link)
if any(value is not None for value in contents.values()):
state = SchemeLink.Active
else:
state = SchemeLink.Empty
link.set_runtime_state(state | SchemeLink.Pending)
if signals:
self.updatesPending.emit()
self._update()
def _update_link(self, link):
"""
Schedule update of a single link.
"""
signals = self.signals_on_link(link)
self._schedule(signals)
def process_queued(self, max_nodes=None):
"""
Process queued signals.
Take one node node from the pending input queue and deliver
all scheduled signals.
"""
if not (max_nodes is None or max_nodes == 1):
warnings.warn(
"`max_nodes` is deprecated and unused (will always equal 1)",
DeprecationWarning, stacklevel=2)
if self.__runtime_state == SignalManager.Processing:
raise RuntimeError("Cannot re-enter 'process_queued'")
if not self._can_process():
raise RuntimeError("Can't process in state %i" % self.__state)
log.info("SignalManager: Processing queued signals")
node_update_front = self.node_update_front()
log.debug("SignalManager: Nodes eligible for update %s",
[node.title for node in node_update_front])
if node_update_front:
node = node_update_front[0]
self._set_runtime_state(SignalManager.Processing)
try:
self.process_node(node)
finally:
self._set_runtime_state(SignalManager.Waiting)
def process_node(self, node):
"""
Process pending input signals for `node`.
"""
signals_in = self.pending_input_signals(node)
self.remove_pending_signals(node)
signals_in = self.compress_signals(signals_in)
log.debug("Processing %r, sending %i signals.",
node.title, len(signals_in))
# Clear the link's pending flag.
for link in {sig.link for sig in signals_in}:
link.set_runtime_state(link.runtime_state() & ~SchemeLink.Pending)
assert ({sig.link for sig in self._input_queue}
.intersection({sig.link for sig in signals_in}) == set([]))
self.processingStarted.emit()
self.processingStarted[SchemeNode].emit(node)
try:
self.send_to_node(node, signals_in)
finally:
self.processingFinished.emit()
self.processingFinished[SchemeNode].emit(node)
def compress_signals(self, signals):
"""
Compress a list of :class:`_Signal` instances to be delivered.
The base implementation returns the list unmodified.
"""
return signals
def send_to_node(self, node, signals):
"""
Abstract. Reimplement in subclass.
Send/notify the :class:`SchemeNode` instance (or whatever
object/instance it is a representation of) that it has new inputs
as represented by the signals list (list of :class:`_Signal`).
"""
raise NotImplementedError
def is_pending(self, node):
"""
Is `node` (class:`SchemeNode`) scheduled for processing (i.e.
it has incoming pending signals).
"""
return node in [signal.link.sink_node for signal in self._input_queue]
def pending_nodes(self):
"""
Return a list of pending nodes.
The nodes are returned in the order they were enqueued for
signal delivery.
Returns
-------
nodes : List[SchemeNode]
"""
return list(unique(sig.link.sink_node for sig in self._input_queue))
def pending_input_signals(self, node):
"""
Return a list of pending input signals for node.
"""
return [signal for signal in self._input_queue
if node is signal.link.sink_node]
def remove_pending_signals(self, node):
"""
Remove pending signals for `node`.
"""
for signal in self.pending_input_signals(node):
try:
self._input_queue.remove(signal)
except ValueError:
pass
def blocking_nodes(self):
"""
Return a list of nodes in a blocking state.
"""
scheme = self.scheme()
return [node for node in scheme.nodes if self.is_blocking(node)]
def is_blocking(self, node):
return False
def node_update_front(self):
"""
Return a list of nodes on the update front, i.e. nodes scheduled for
an update that have no ancestor which is either itself scheduled
for update or is in a blocking state)
.. note::
The node's ancestors are only computed over enabled links.
"""
scheme = self.scheme()
def expand(node):
return [link.sink_node for
link in scheme.find_links(source_node=node) if
link.enabled]
components = strongly_connected_components(scheme.nodes, expand)
node_scc = {node: scc for scc in components for node in scc}
def isincycle(node):
return len(node_scc[node]) > 1
# a list of all nodes currently active/executing a task.
blocking_nodes = set(self.blocking_nodes())
dependents = partial(dependent_nodes, scheme)
blocked_nodes = reduce(set.union,
map(dependents, blocking_nodes),
set(blocking_nodes))
pending = self.pending_nodes()
pending_downstream = set()
for n in pending:
depend = set(dependents(n))
if isincycle(n):
# a pending node in a cycle would would have a circular
# dependency on itself, preventing any progress being made
# by the workflow execution.
cc = node_scc[n]
depend -= set(cc)
pending_downstream.update(depend)
log.debug("Pending nodes: %s", pending)
log.debug("Blocking nodes: %s", blocking_nodes)
noneligible = pending_downstream | blocked_nodes
return [node for node in pending if node not in noneligible]
@Slot()
def __process_next(self):
if not self.__state == SignalManager.Running:
log.debug("Received 'UpdateRequest' while not in 'Running' state")
return
if self.__runtime_state == SignalManager.Processing:
# This happens if someone calls QCoreApplication.processEvents
# from the signal handlers.
# A `__process_next` must be rescheduled when exiting
# process_queued.
log.warning("Received 'UpdateRequest' while in 'process_queued'. "
"An update will be re-scheduled when exiting the "
"current update.")
self.__reschedule = True
return
nbusy = len(self.blocking_nodes())
log.info("'UpdateRequest' event, queued signals: %i, nbusy: %i "
"(MAX_CONCURRENT: %i)",
len(self._input_queue), nbusy, MAX_CONCURRENT)
if self._input_queue and nbusy < MAX_CONCURRENT:
self.process_queued()
if self.__reschedule and self.__state == SignalManager.Running:
self.__reschedule = False
log.debug("Rescheduling signal update")
self.__update_timer.start()
nbusy = len(self.blocking_nodes())
if self.node_update_front() and nbusy < MAX_CONCURRENT:
log.debug("More nodes are eligible for an update. "
"Scheduling another update.")
self._update()
def _update(self):
"""
Schedule processing at a later time.
"""
if self.__state == SignalManager.Running and \
not self.__update_timer.isActive():
self.__update_timer.start()
class SignalManager(QObject):
"""
SignalManager handles the runtime signal propagation for a :class:`.Scheme`
instance.
Note
----
If a scheme instance is passed as a parent to the constructor it is also
set as the workflow model.
"""
class State(enum.IntEnum):
"""
SignalManager state flags.
.. seealso:: :func:`SignalManager.state()`
"""
#: The manager is running, i.e. it propagates signals
Running = 0
#: The manager is stopped. It does not track node output changes,
#: and does not deliver signals to dependent nodes
Stopped = 1
#: The manager is paused. It still tracks node output changes, but
#: does not deliver new signals to dependent nodes. The pending signals
#: will be delivered once it enters Running state again
Paused = 2
#: The manager is running, i.e. it propagates signals
Running = State.Running
#: The manager is stopped. It does not track node ouput changes,
#: and does not deliver signals to dependent nodes
Stopped = State.Stopped
#: The manager is paused. It still tracks node output changes, but
#: does not deliver new signals to dependent nodes. The pending signals
#: will be delivered once it enters Running state again
Paused = Stopped.Paused
# unused; back-compatibility
Error = 3
class RuntimeState(enum.IntEnum):
"""
SignalManager runtime state.
See Also
--------
SignalManager.runtime_state
"""
#: Waiting, idle state. The signal queue is empty
Waiting = 0
#: ...
Processing = 1
Waiting = RuntimeState.Waiting
Processing = RuntimeState.Processing
#: Emitted when the state of the signal manager changes.
stateChanged = pyqtSignal(int)
#: Emitted when signals are added to the queue.
updatesPending = pyqtSignal()
#: Emitted right before a `SchemeNode` instance has its inputs updated.
processingStarted = pyqtSignal([], [SchemeNode])
#: Emitted right after a `SchemeNode` instance has had its inputs updated.
processingFinished = pyqtSignal([], [SchemeNode])
#: Emitted when `SignalManager`'s runtime state changes.
runtimeStateChanged = pyqtSignal(int)
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.__workflow = None # type: Optional[Scheme]
self.__input_queue = [] # type: List[Signal]
# mapping a node to its current outputs
self.__node_outputs = {} # type: Dict[Node, Dict[OutputSignal, Dict[Any, Any]]]
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
# A flag indicating if UpdateRequest event should be rescheduled
self.__reschedule = False
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
if isinstance(parent, Scheme):
self.set_workflow(parent)
def _can_process(self):
"""
Return a bool indicating if the manger can enter the main
processing loop.
"""
return self.__state not in [SignalManager.Error, SignalManager.Stopped]
def workflow(self):
# type: () -> Scheme
"""
Return the :class:`Scheme` instance.
"""
return self.__workflow
#: Alias
scheme = workflow
def set_workflow(self, workflow):
# type: (Scheme) -> None
"""
Set the workflow model.
Parameters
----------
workflow : Scheme
"""
if workflow is self.__workflow:
return
if self.__workflow is not None:
for link in self.__workflow.links:
link.enabled_changed.disconnect(self.link_enabled_changed)
self.__workflow.node_added.disconnect(self.on_node_added)
self.__workflow.node_removed.disconnect(self.on_node_removed)
self.__workflow.link_added.disconnect(self.link_added)
self.__workflow.link_removed.disconnect(self.link_removed)
self.__workflow.removeEventFilter(self)
self.__node_outputs = {}
self.__input_queue = []
self.__workflow = workflow
if workflow is not None:
workflow.node_added.connect(self.on_node_added)
workflow.node_removed.connect(self.on_node_removed)
workflow.link_added.connect(self.link_added)
workflow.link_removed.connect(self.link_removed)
for node in workflow.nodes:
self.__node_outputs[node] = defaultdict(dict)
for link in workflow.links:
link.enabled_changed.connect(self.link_enabled_changed)
workflow.installEventFilter(self)
def has_pending(self):
"""
Does the manager have any signals to deliver?
"""
return bool(self.__input_queue)
def start(self):
"""
Start the update loop.
Note
----
The updates will not happen until the control reaches the Qt event
loop.
"""
if self.__state != SignalManager.Running:
self.__state = SignalManager.Running
self.stateChanged.emit(SignalManager.Running)
self._update()
def stop(self):
"""
Stop the update loop.
Note
----
If the `SignalManager` is currently in `process_queues` it will
still update all current pending signals, but will not re-enter
until `start()` is called again.
"""
if self.__state != SignalManager.Stopped:
self.__state = SignalManager.Stopped
self.stateChanged.emit(SignalManager.Stopped)
self.__update_timer.stop()
def pause(self):
"""
Pause the delivery of signals.
"""
if self.__state != SignalManager.Paused:
self.__state = SignalManager.Paused
self.stateChanged.emit(SignalManager.Paused)
self.__update_timer.stop()
def resume(self):
"""
Resume the delivery of signals.
"""
if self.__state == SignalManager.Paused:
self.__state = SignalManager.Running
self.stateChanged.emit(self.__state)
self._update()
def step(self):
"""
Deliver signals to a single node (only applicable while the `state()`
is `Paused`).
"""
if self.__state == SignalManager.Paused:
self.process_queued()
def state(self):
# type: () -> State
"""
Return the current state.
Return
------
state : SignalManager.State
"""
return self.__state
def _set_runtime_state(self, state):
"""
Set the runtime state.
Should only be called by `SignalManager` implementations.
"""
if self.__runtime_state != state:
self.__runtime_state = state
self.runtimeStateChanged.emit(self.__runtime_state)
def runtime_state(self):
# type: () -> RuntimeState
"""
Return the runtime state. This can be `SignalManager.Waiting`
or `SignalManager.Processing`.
"""
return self.__runtime_state
def on_node_removed(self, node):
# remove all pending input signals for node so we don't get
# stale references in process_node.
# NOTE: This does not remove output signals for this node. In
# particular the final 'None' will be delivered to the sink
# nodes even after the source node is no longer in the scheme.
log.info("Removing pending signals for '%s'.", node.title)
self.remove_pending_signals(node)
del self.__node_outputs[node]
def on_node_added(self, node):
self.__node_outputs[node] = defaultdict(dict)
def link_added(self, link):
# push all current source values to the sink
link.set_runtime_state(SchemeLink.Empty)
if link.enabled:
log.info("Scheduling signal data update for '%s'.", link)
self._schedule(self.signals_on_link(link))
self._update()
link.enabled_changed.connect(self.link_enabled_changed)
def link_removed(self, link):
# purge all values in sink's queue
log.info("Scheduling signal data purge (%s).", link)
self.purge_link(link)
link.enabled_changed.disconnect(self.link_enabled_changed)
def link_enabled_changed(self, enabled):
if enabled:
link = self.sender()
log.info("Link %s enabled. Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
def signals_on_link(self, link):
# type: (SchemeLink) -> List[Signal]
"""
Return :class:`Signal` instances representing the current values
present on the link.
"""
items = self.link_contents(link)
signals = []
for key, value in items.items():
signals.append(Signal(link, value, key))
return signals
def link_contents(self, link):
"""
Return the contents on link.
"""
node, channel = link.source_node, link.source_channel
if node in self.__node_outputs:
return self.__node_outputs[node][channel]
else:
# if the the node was already removed its tracked outputs in
# __node_outputs are cleared, however the final 'None' signal
# deliveries for the link are left in the _input_queue.
pending = [sig for sig in self.__input_queue
if sig.link is link]
return {sig.id: sig.value for sig in pending}
def send(self, node, channel, value, id):
# type: (SchemeNode, OutputSignal, Any, Any) -> None
"""
Send the `value` with `id` on an output `channel` from node.
Schedule the signal delivery to all dependent nodes
Parameters
----------
node : SchemeNode
The originating node.
channel : OutputSignal
The nodes output on which the value is sent.
value : Any
The value to send,
id : Any
Signal id.
"""
log.debug("%r sending %r (id: %r) on channel %r",
node.title, type(value), id, channel.name)
scheme = self.scheme()
self.__node_outputs[node][channel][id] = value
links = scheme.find_links(source_node=node, source_channel=channel)
links = filter(is_enabled, links)
signals = []
for link in links:
signals.append(Signal(link, value, id))
self._schedule(signals)
def purge_link(self, link):
"""
Purge the link (send None for all ids currently present)
"""
contents = self.link_contents(link)
ids = contents.keys()
signals = [Signal(link, None, id) for id in ids]
self._schedule(signals)
def _schedule(self, signals):
"""
Schedule a list of :class:`Signal` for delivery.
"""
self.__input_queue.extend(signals)
for link in {sig.link for sig in signals}:
# update the SchemeLink's runtime state flags
contents = self.link_contents(link)
if any(value is not None for value in contents.values()):
state = SchemeLink.Active
else:
state = SchemeLink.Empty
link.set_runtime_state(state | SchemeLink.Pending)
if signals:
self.updatesPending.emit()
self._update()
def _update_link(self, link):
"""
Schedule update of a single link.
"""
signals = self.signals_on_link(link)
self._schedule(signals)
def process_queued(self, max_nodes=None):
"""
Process queued signals.
Take one node node from the pending input queue and deliver
all scheduled signals.
"""
if not (max_nodes is None or max_nodes == 1):
warnings.warn(
"`max_nodes` is deprecated and unused (will always equal 1)",
DeprecationWarning, stacklevel=2)
if self.__runtime_state == SignalManager.Processing:
raise RuntimeError("Cannot re-enter 'process_queued'")
if not self._can_process():
raise RuntimeError("Can't process in state %i" % self.__state)
log.info("SignalManager: Processing queued signals")
node_update_front = self.node_update_front()
log.debug("SignalManager: Nodes eligible for update %s",
[node.title for node in node_update_front])
if node_update_front:
node = node_update_front[0]
self._set_runtime_state(SignalManager.Processing)
try:
self.process_node(node)
finally:
self._set_runtime_state(SignalManager.Waiting)
def process_node(self, node):
"""
Process pending input signals for `node`.
"""
signals_in = self.pending_input_signals(node)
self.remove_pending_signals(node)
signals_in = self.compress_signals(signals_in)
log.debug("Processing %r, sending %i signals.",
node.title, len(signals_in))
# Clear the link's pending flag.
for link in {sig.link for sig in signals_in}:
link.set_runtime_state(link.runtime_state() & ~SchemeLink.Pending)
def process_dynamic(signals):
# type: (List[Signal]) -> List[Signal]
"""
Process dynamic signals; Update the link's dynamic_enabled flag if
the value is valid; replace values that do not type check with
`None`
"""
res = []
for sig in signals:
# Check and update the dynamic link state
link = sig.link
if sig.link.is_dynamic():
link.dynamic_enabled = can_enable_dynamic(link, sig.value)
if not link.dynamic_enabled:
# Send None instead
sig = Signal(link, None, sig.id)
res.append(sig)
return res
signals_in = process_dynamic(signals_in)
assert ({sig.link for sig in self.__input_queue}
.intersection({sig.link for sig in signals_in}) == set([]))
self.processingStarted.emit()
self.processingStarted[SchemeNode].emit(node)
try:
self.send_to_node(node, signals_in)
finally:
self.processingFinished.emit()
self.processingFinished[SchemeNode].emit(node)
def compress_signals(self, signals):
# type: (List[Signal]) -> List[Signal]
"""
Compress a list of :class:`Signal` instances to be delivered.
Before the signal values are delivered to the sink node they can be
optionally `compressed`, i.e. values can be merged or dropped
depending on the execution semantics.
The input list is in the order that the signals were enqueued.
The base implementation returns the list unmodified.
Parameters
----------
signals : List[Signal]
Return
------
signals : List[Signal]
"""
return signals
def send_to_node(self, node, signals):
# type: (SchemeNode, List[Signal]) -> None
"""
Abstract. Reimplement in subclass.
Send/notify the `node` instance (or whatever object/instance it is a
representation of) that it has new inputs as represented by the
`signals` list).
Parameters
----------
node : SchemeNode
signals : List[Signal]
"""
raise NotImplementedError
def is_pending(self, node):
# type: (SchemeNode) -> bool
"""
Is `node` (class:`SchemeNode`) scheduled for processing (i.e.
it has incoming pending signals).
Parameters
----------
node : SchemeNode
Returns
-------
pending : bool
"""
return node in [signal.link.sink_node for signal in self.__input_queue]
def pending_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of pending nodes.
The nodes are returned in the order they were enqueued for
signal delivery.
Returns
-------
nodes : List[SchemeNode]
"""
return list(unique(sig.link.sink_node for sig in self.__input_queue))
def pending_input_signals(self, node):
# type: (SchemeNode) -> List[Signal]
"""
Return a list of pending input signals for node.
"""
return [signal for signal in self.__input_queue
if node is signal.link.sink_node]
def remove_pending_signals(self, node):
# type: (SchemeNode) -> None
"""
Remove pending signals for `node`.
"""
for signal in self.pending_input_signals(node):
try:
self.__input_queue.remove(signal)
except ValueError:
pass
def blocking_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of nodes in a blocking state.
"""
scheme = self.scheme()
return [node for node in scheme.nodes if self.is_blocking(node)]
def is_blocking(self, node):
# type: (SchemeNode) -> bool
"""
Is the node in `blocking` state.
Is it currently in a state where will produce new outputs and
therefore no signals should be delivered to dependent nodes until
it does so.
The default implementation returns False.
"""
# TODO: this needs a different name
return False
def node_update_front(self):
# type: () -> List[SchemeNode]
"""
Return a list of nodes on the update front, i.e. nodes scheduled for
an update that have no ancestor which is either itself scheduled
for update or is in a blocking state).
Note
----
The node's ancestors are only computed over enabled links.
"""
scheme = self.scheme()
def expand(node):
return [link.sink_node
for link in scheme.find_links(source_node=node)
if link.enabled]
components = strongly_connected_components(scheme.nodes, expand)
node_scc = {node: scc for scc in components for node in scc}
def isincycle(node):
return len(node_scc[node]) > 1
# a list of all nodes currently active/executing a task.
blocking_nodes = set(self.blocking_nodes())
dependents = partial(dependent_nodes, scheme)
blocked_nodes = reduce(set.union,
map(dependents, blocking_nodes),
set(blocking_nodes))
pending = self.pending_nodes()
pending_downstream = set()
for n in pending:
depend = set(dependents(n))
if isincycle(n):
# a pending node in a cycle would would have a circular
# dependency on itself, preventing any progress being made
# by the workflow execution.
cc = node_scc[n]
depend -= set(cc)
pending_downstream.update(depend)
log.debug("Pending nodes: %s", pending)
log.debug("Blocking nodes: %s", blocking_nodes)
noneligible = pending_downstream | blocked_nodes
return [node for node in pending if node not in noneligible]
@Slot()
def __process_next(self):
if not self.__state == SignalManager.Running:
log.debug("Received 'UpdateRequest' while not in 'Running' state")
return
if self.__runtime_state == SignalManager.Processing:
# This happens if QCoreApplication.processEvents is called from
# the input handlers. A `__process_next` must be rescheduled when
# exiting process_queued.
log.warning("Received 'UpdateRequest' while in 'process_queued'. "
"An update will be re-scheduled when exiting the "
"current update.")
self.__reschedule = True
return
nbusy = len(self.blocking_nodes())
log.info("'UpdateRequest' event, queued signals: %i, nbusy: %i "
"(MAX_CONCURRENT: %i)",
len(self.__input_queue), nbusy, MAX_CONCURRENT)
if self.__input_queue and nbusy < MAX_CONCURRENT:
self.process_queued()
if self.__reschedule and self.__state == SignalManager.Running:
self.__reschedule = False
log.debug("Rescheduling signal update")
self.__update_timer.start()
nbusy = len(self.blocking_nodes())
if self.node_update_front() and nbusy < MAX_CONCURRENT:
log.debug("More nodes are eligible for an update. "
"Scheduling another update.")
self._update()
def _update(self):
"""
Schedule processing at a later time.
"""
if self.__state == SignalManager.Running and \
not self.__update_timer.isActive():
self.__update_timer.start()
def eventFilter(self, receiver, event):
"""
Reimplemented.
"""
if event.type() == QEvent.DeferredDelete \
and receiver is self.__workflow:
# ?? This is really, probably, mostly, likely not needed. Should
# just raise error from __process_next.
state = self.runtime_state()
if state == SignalManager.Processing:
log.critical(
"The workflow model %r received a deferred delete request "
"while performing an input update. "
"Deferring a 'DeferredDelete' event for the workflow "
"until SignalManager exits the current update step.",
self.__workflow
)
warnings.warn(
"The workflow model received a deferred delete request "
"while updating inputs. In the future this will raise "
"a RuntimeError", _FutureRuntimeWarning,
)
event.setAccepted(False)
self.processingFinished.connect(self.__workflow.deleteLater)
self.stop()
return True
return super().eventFilter(receiver, event)
class WidgetManager(QObject):
"""
WidgetManager class is responsible for creation, tracking and deletion
of UI elements constituting an interactive workflow.
It does so by reacting to changes in the underlying workflow model,
creating and destroying the components when needed.
This is an abstract class, subclassed MUST reimplement at least
:func:`create_widget_for_node` and :func:`delete_widget_for_node`.
The widgets created with :func:`create_widget_for_node` will automatically
receive dispatched events:
* :data:`WorkflowEvent.InputLinkAdded` - when a new input link is added to
the workflow.
* :data:`LinkEvent.InputLinkRemoved` - when a input link is removed
* :data:`LinkEvent.OutputLinkAdded` - when a new output link is added to
the workflow
* :data:`LinkEvent.InputLinkRemoved` - when a output link is removed
* :data:`WorkflowEnvEvent.WorkflowEnvironmentChanged` - when the
workflow environment changes.
.. seealso:: :func:`.Scheme.add_link()`, :func:`Scheme.remove_link`,
:func:`.Scheme.runtime_env`
"""
#: A new QWidget was created and added by the manager.
widget_for_node_added = Signal(SchemeNode, QWidget)
#: A QWidget was removed, hidden and will be deleted when appropriate.
widget_for_node_removed = Signal(SchemeNode, QWidget)
class CreationPolicy(enum.Enum):
"""
Widget Creation Policy.
"""
#: Widgets are scheduled to be created from the event loop, or when
#: first accessed with `widget_for_node`
Normal = "Normal"
#: Widgets are created immediately when a node is added to the
#: workflow model.
Immediate = "Immediate"
#: Widgets are created only when first accessed with `widget_for_node`
#: (e.g. when activated in the view).
OnDemand = "OnDemand"
Normal = CreationPolicy.Normal
Immediate = CreationPolicy.Immediate
OnDemand = CreationPolicy.OnDemand
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__workflow = None # type: Optional[Scheme]
self.__creation_policy = WidgetManager.Normal
self.__float_widgets_on_top = False
self.__item_for_node = {} # type: Dict[SchemeNode, Item]
self.__item_for_widget = {} # type: Dict[QWidget, Item]
self.__init_queue = deque() # type: Deque[SchemeNode]
self.__init_timer = QTimer(self, singleShot=True)
self.__init_timer.timeout.connect(self.__process_init_queue)
self.__activation_monitor = ActivationMonitor(self)
self.__activation_counter = itertools.count()
self.__activation_monitor.activated.connect(self.__mark_activated)
def set_workflow(self, workflow):
# type: (Scheme) -> None
"""
Set the workflow.
"""
if workflow is self.__workflow:
return
if self.__workflow is not None:
# cleanup
for node in self.__workflow.nodes:
self.__remove_node(node)
self.__workflow.node_added.disconnect(self.__on_node_added)
self.__workflow.node_removed.disconnect(self.__on_node_removed)
self.__workflow.link_added.disconnect(self.__on_link_added)
self.__workflow.link_removed.disconnect(self.__on_link_removed)
self.__workflow.runtime_env_changed.disconnect(self.__on_env_changed)
self.__workflow.removeEventFilter(self)
self.__workflow = workflow
workflow.node_added.connect(
self.__on_node_added, Qt.UniqueConnection)
workflow.node_removed.connect(
self.__on_node_removed, Qt.UniqueConnection)
workflow.link_added.connect(
self.__on_link_added, Qt.UniqueConnection)
workflow.link_removed.connect(
self.__on_link_removed, Qt.UniqueConnection)
workflow.runtime_env_changed.connect(
self.__on_env_changed, Qt.UniqueConnection)
workflow.installEventFilter(self)
for node in workflow.nodes:
self.__add_node(node)
def workflow(self):
return self.__workflow
scheme = workflow
set_scheme = set_workflow
def set_creation_policy(self, policy):
# type: (CreationPolicy) -> None
"""
Set the widget creation policy.
"""
if self.__creation_policy != policy:
self.__creation_policy = policy
if self.__creation_policy == WidgetManager.Immediate:
self.__init_timer.stop()
# create all
if self.__workflow is not None:
for node in self.__workflow.nodes:
self.ensure_created(node)
elif self.__creation_policy == WidgetManager.Normal:
if not self.__init_timer.isActive() and self.__init_queue:
self.__init_timer.start()
elif self.__creation_policy == WidgetManager.OnDemand:
self.__init_timer.stop()
else:
assert False
def creation_policy(self):
"""
Return the current widget creation policy.
"""
return self.__creation_policy
def create_widget_for_node(self, node):
# type: (SchemeNode) -> QWidget
"""
Create and initialize a widget for node.
This is an abstract method. Subclasses must reimplemented it.
"""
raise NotImplementedError()
def delete_widget_for_node(self, node, widget):
"""
Remove and delete widget for node.
This is an abstract method. Subclasses must reimplemented it.
"""
raise NotImplementedError()
def node_for_widget(self, widget):
# type: (QWidget) -> Optional[SchemeNode]
"""
Return the node for widget.
"""
item = self.__item_for_widget.get(widget)
if item is not None:
return item.node
else:
return None
def widget_for_node(self, node):
# type: (SchemeNode) -> Optional[QWidget]
"""
Return the widget for node.
"""
self.ensure_created(node)
item = self.__item_for_node.get(node)
return item.widget if item is not None else None
def __add_widget_for_node(self, node):
# type: (SchemeNode) -> None
item = self.__item_for_node.get(node)
if item is not None:
return
if node not in self.__workflow.nodes:
return
if node in self.__init_queue:
self.__init_queue.remove(node)
item = Item(node, None, -1)
# Insert on the node -> item mapping.
self.__item_for_node[node] = item
log.debug("Creating widget for node %s", node)
try:
w = self.create_widget_for_node(node)
except Exception: # pylint: disable=broad-except
log.critical("", exc_info=True)
lines = traceback.format_exception(*sys.exc_info())
text = "".join(lines)
errorwidget = QLabel(
textInteractionFlags=Qt.TextSelectableByMouse, wordWrap=True,
objectName="widgetmanager-error-placeholder",
text="<pre>" + escape(text) + "</pre>"
)
item.errorwidget = errorwidget
node.set_state_message(UserMessage(text, UserMessage.Error, 0))
return
else:
item.widget = w
self.__item_for_widget[w] = item
self.__set_float_on_top_flag(w)
w.installEventFilter(self.__activation_monitor)
# Up shortcut (activate/open parent)
up_shortcut = QShortcut(
QKeySequence(Qt.ControlModifier + Qt.Key_Up), w)
up_shortcut.activated.connect(self.__on_activate_parent)
# send all the post creation notification events
workflow = self.__workflow
assert workflow is not None
inputs = workflow.find_links(sink_node=node)
for link in inputs:
ev = LinkEvent(LinkEvent.InputLinkAdded, link)
QCoreApplication.sendEvent(w, ev)
outputs = workflow.find_links(source_node=node)
for link in outputs:
ev = LinkEvent(LinkEvent.OutputLinkAdded, link)
QCoreApplication.sendEvent(w, ev)
self.widget_for_node_added.emit(node, w)
def ensure_created(self, node):
# type: (SchemeNode) -> None
"""
Ensure that the widget for node is created.
"""
if node not in self.__workflow.nodes:
return
item = self.__item_for_node.get(node)
if item is None:
self.__add_widget_for_node(node)
def __on_node_added(self, node): # type: (SchemeNode) -> None
assert self.__workflow is not None
assert node in self.__workflow.nodes
assert node not in self.__item_for_node
self.__add_node(node)
def __add_node(self, node): # type: (SchemeNode) -> None
# add node for tracking
node.installEventFilter(self)
if self.__creation_policy == WidgetManager.Immediate:
self.ensure_created(node)
elif self.__creation_policy == WidgetManager.Normal:
self.__init_queue.append(node)
self.__init_timer.start()
def __on_node_removed(self, node): # type: (SchemeNode) -> None
assert self.__workflow is not None
assert node not in self.__workflow.nodes
self.__remove_node(node)
def __remove_node(self, node): # type: (SchemeNode) -> None
# remove the node and its widget from tracking.
node.removeEventFilter(self)
if node in self.__init_queue:
self.__init_queue.remove(node)
item = self.__item_for_node.get(node)
if item is not None and item.widget is not None:
widget = item.widget
assert widget in self.__item_for_widget
del self.__item_for_widget[widget]
widget.removeEventFilter(self.__activation_monitor)
item.widget = None
self.widget_for_node_removed.emit(node, widget)
self.delete_widget_for_node(node, widget)
if item is not None:
del self.__item_for_node[node]
@Slot()
def __process_init_queue(self):
log.debug("__process_init_queue")
while self.__init_queue:
node = self.__init_queue.popleft()
assert node in self.__workflow.nodes
self.ensure_created(node)
def __on_link_added(self, link): # type: (SchemeLink) -> None
assert link.source_node in self.__workflow.nodes
assert link.sink_node in self.__workflow.nodes
source = self.__item_for_widget.get(link.source_node)
sink = self.__item_for_widget.get(link.sink_node)
# notify the node gui of an added link
if source is not None:
ev = LinkEvent(LinkEvent.OutputLinkAdded, link)
QCoreApplication.sendEvent(source.widget, ev)
if sink is not None:
ev = LinkEvent(LinkEvent.InputLinkAdded, link)
QCoreApplication.sendEvent(sink.widget, ev)
def __on_link_removed(self, link): # type: (SchemeLink) -> None
assert link.source_node in self.__workflow.nodes
assert link.sink_node in self.__workflow.nodes
source = self.__item_for_widget.get(link.source_node)
sink = self.__item_for_widget.get(link.sink_node)
# notify the node gui of an removed link
if source is not None:
ev = LinkEvent(LinkEvent.OutputLinkRemoved, link)
QCoreApplication.sendEvent(source.widget, ev)
if sink is not None:
ev = LinkEvent(LinkEvent.InputLinkRemoved, link)
QCoreApplication.sendEvent(sink.widget, ev)
def __mark_activated(self, widget): # type: (QWidget) -> None
# Update the tracked stacking order for `widget`
item = self.__item_for_widget.get(widget)
if item is not None:
item.activation_order = next(self.__activation_counter)
def activate_widget_for_node(self, node, widget):
# type: (SchemeNode, QWidget) -> None
"""
Activate the widget for node (show and raise above other)
"""
if widget.windowState() == Qt.WindowMinimized:
widget.showNormal()
widget.setVisible(True)
widget.raise_()
widget.activateWindow()
def activate_window_group(self, group):
# type: (Scheme.WindowGroup) -> None
self.restore_window_state(group.state)
def raise_widgets_to_front(self):
"""
Raise all current visible widgets to the front.
The widgets will be stacked by activation order.
"""
workflow = self.__workflow
if workflow is None:
return
items = filter(
lambda item: (
item.widget.isVisible()
if item is not None and item.widget is not None
else False)
,
map(self.__item_for_node.get, workflow.nodes))
self.__raise_and_activate(items)
def set_float_widgets_on_top(self, float_on_top):
"""
Set `Float Widgets on Top` flag on all widgets.
"""
self.__float_widgets_on_top = float_on_top
for item in self.__item_for_node.values():
if item.widget is not None:
self.__set_float_on_top_flag(item.widget)
def save_window_state(self):
# type: () -> List[Tuple[SchemeNode, bytes]]
"""
Save current open window arrangement.
"""
workflow = self.__workflow # type: Scheme
state = []
for node in workflow.nodes: # type: SchemeNode
item = self.__item_for_node.get(node, None)
if item is None:
continue
stackorder = item.activation_order
if item.widget is not None and not item.widget.isHidden():
data = self.save_widget_geometry(node, item.widget)
state.append((stackorder, node, data))
state = [(node, data)
for _, node, data in sorted(state, key=lambda t: t[0])]
return state
def restore_window_state(self, state):
# type: (List[Tuple[SchemeNode, bytes]]) -> None
"""
Restore the window state.
"""
workflow = self.__workflow # type: Scheme
visible = {node for node, _ in state}
# first hide all other widgets
for node in workflow.nodes:
if node not in visible:
# avoid creating widgets if not needed
item = self.__item_for_node.get(node, None)
if item is not None and item.widget is not None:
item.widget.hide()
allnodes = set(workflow.nodes)
# restore state for visible group; windows are stacked as they appear
# in the state list.
w = None
for node, state in filter(lambda t: t[0] in allnodes, state):
w = self.widget_for_node(node) # also create it if needed
if w is not None:
w.show()
self.restore_widget_geometry(node, w, state)
w.raise_()
self.__mark_activated(w)
# activate (give focus to) the last window
if w is not None:
w.activateWindow()
def save_widget_geometry(self, node, widget):
# type: (SchemeNode, QWidget) -> bytes
"""
Save and return the current geometry and state for node.
"""
return b''
def restore_widget_geometry(self, node, widget, state):
# type: (SchemeNode, QWidget, bytes) -> bool
"""
Restore the widget geometry and state for node.
Return True if the geometry was restored successfully.
The default implementation does nothing.
"""
return False
def __raise_and_activate(self, items):
# type: (Iterable[Item]) -> None
"""Show and raise a set of widgets."""
# preserve the tracked stacking order
items = sorted(items, key=lambda item: item.activation_order)
w = None
for item in items:
if item.widget is not None:
w = item.widget
elif item.errorwidget is not None:
w = item.errorwidget
else:
continue
w.show()
w.raise_()
if w is not None:
# give focus to the last activated top window
w.activateWindow()
def __activate_widget_for_node(self, node): # type: (SchemeNode) -> None
# activate the widget for the node.
self.ensure_created(node)
item = self.__item_for_node.get(node)
if item is None:
return
if item.widget is not None:
self.activate_widget_for_node(node, item.widget)
elif item.errorwidget is not None:
item.errorwidget.show()
item.errorwidget.raise_()
item.errorwidget.activateWindow()
def __on_activate_parent(self):
event = WorkflowEvent(WorkflowEvent.ActivateParentRequest)
QCoreApplication.sendEvent(self.scheme(), event)
def eventFilter(self, recv, event):
# type: (QObject, QEvent) -> bool
if event.type() == NodeEvent.NodeActivateRequest \
and isinstance(recv, SchemeNode):
self.__activate_widget_for_node(recv)
return False
def __set_float_on_top_flag(self, widget):
"""Set or unset widget's float on top flag"""
should_float_on_top = self.__float_widgets_on_top
float_on_top = bool(widget.windowFlags() & Qt.WindowStaysOnTopHint)
if float_on_top == should_float_on_top:
return
widget_was_visible = widget.isVisible()
if should_float_on_top:
widget.setWindowFlags(
widget.windowFlags() | Qt.WindowStaysOnTopHint)
else:
widget.setWindowFlags(
widget.windowFlags() & ~Qt.WindowStaysOnTopHint)
# Changing window flags hid the widget
if widget_was_visible:
widget.show()
def __on_env_changed(self, key, newvalue, oldvalue):
# Notify widgets of a runtime environment change
for item in self.__item_for_node.values():
if item.widget is not None:
ev = WorkflowEnvChanged(key, newvalue, oldvalue)
QCoreApplication.sendEvent(item.widget, ev)
def actions_for_context_menu(self, node):
# type: (SchemeNode) -> List[QAction]
"""
Return a list of extra actions that can be inserted into context
menu in the workflow editor.
Subclasses can reimplement this method to extend the default context
menu.
Parameters
----------
node: SchemeNode
The node for which the context menu is requested.
Return
------
actions: List[QAction]
Actions that are appended to the default menu.
"""
return []
class WidgetManager(QObject):
"""
OWWidget instance manager class.
This class handles the lifetime of OWWidget instances in a
:class:`WidgetsScheme`.
"""
#: A new OWWidget was created and added by the manager.
widget_for_node_added = Signal(SchemeNode, QWidget)
#: An OWWidget was removed, hidden and will be deleted when appropriate.
widget_for_node_removed = Signal(SchemeNode, QWidget)
class ProcessingState(enum.IntEnum):
"""Widget processing state flags"""
#: Signal manager is updating/setting the widget's inputs
InputUpdate = 1
#: Widget has entered a blocking state (OWWidget.isBlocking)
BlockingUpdate = 2
#: Widget has entered processing state
ProcessingUpdate = 4
#: Widget is still in the process of initialization
Initializing = 8
InputUpdate, BlockingUpdate, ProcessingUpdate, Initializing = ProcessingState
#: State mask for widgets that cannot be deleted immediately
#: (see __try_delete)
_DelayDeleteMask = InputUpdate | BlockingUpdate
#: Widget initialization states
Delayed = namedtuple("Delayed", ["node"])
PartiallyInitialized = namedtuple("Materializing",
["node", "partially_initialized_widget"])
Materialized = namedtuple("Materialized", ["node", "widget"])
class CreationPolicy(enum.Enum):
"""Widget Creation Policy"""
#: Widgets are scheduled to be created from the event loop, or when
#: first accessed with `widget_for_node`
Normal = "Normal"
#: Widgets are created immediately when added to the workflow model
Immediate = "Immediate"
#: Widgets are created only when first accessed with `widget_for_node`
OnDemand = "OnDemand"
Normal, Immediate, OnDemand = CreationPolicy
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__scheme = None
self.__signal_manager = None
self.__widgets = []
self.__initstate_for_node = {}
self.__creation_policy = WidgetManager.Normal
#: a queue of all nodes whose widgets are scheduled for
#: creation/initialization
self.__init_queue = deque() # type: Deque[SchemeNode]
#: Timer for scheduling widget initialization
self.__init_timer = QTimer(self, interval=0, singleShot=True)
self.__init_timer.timeout.connect(self.__create_delayed)
#: A mapping of SchemeNode -> OWWidget (note: a mapping is only added
#: after the widget is actually created)
self.__widget_for_node = {}
#: a mapping of OWWidget -> SchemeNode
self.__node_for_widget = {}
# Widgets that were 'removed' from the scheme but were at
# the time in an input update loop and could not be deleted
# immediately
self.__delay_delete = set()
#: processing state flags for all widgets (including the ones
#: in __delay_delete).
#: Note: widgets which have not yet been created do not have an entry
self.__widget_processing_state = {}
# Tracks the widget in the update loop by the SignalManager
self.__updating_widget = None
# Widgets float above other windows
self.__float_widgets_on_top = False
if hasattr(qApp, "applicationStateChanged"):
# disables/enables widget floating when app (de)activates
# available in Qt >= 5.2
def reapply_float_on_top():
self.set_float_widgets_on_top(self.__float_widgets_on_top)
qApp.applicationStateChanged.connect(reapply_float_on_top)
def set_scheme(self, scheme):
"""
Set the :class:`WidgetsScheme` instance to manage.
"""
self.__scheme = scheme
self.__signal_manager = scheme.findChild(SignalManager)
self.__signal_manager.processingStarted[SchemeNode].connect(
self.__on_processing_started)
self.__signal_manager.processingFinished[SchemeNode].connect(
self.__on_processing_finished)
scheme.node_added.connect(self.add_widget_for_node)
scheme.node_removed.connect(self.remove_widget_for_node)
scheme.runtime_env_changed.connect(self.__on_env_changed)
scheme.installEventFilter(self)
def scheme(self):
"""
Return the scheme instance on which this manager is installed.
"""
return self.__scheme
def signal_manager(self):
"""
Return the signal manager in use on the :func:`scheme`.
"""
return self.__signal_manager
def widget_for_node(self, node):
"""
Return the OWWidget instance for the scheme node.
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Delayed):
# Create the widget now if it is still pending
state = self.__materialize(state)
return state.widget
elif isinstance(state, WidgetManager.PartiallyInitialized):
widget = state.partially_initialized_widget
log.warning(
"WidgetManager.widget_for_node: "
"Accessing a partially created widget instance. "
"This is most likely a result of explicit "
"QApplication.processEvents call from the '%s.%s' "
"widgets __init__.",
type(widget).__module__,
type(widget).__name__)
return widget
elif isinstance(state, WidgetManager.Materialized):
return state.widget
else:
assert False
def node_for_widget(self, widget):
"""
Return the SchemeNode instance for the OWWidget.
Raise a KeyError if the widget does not map to a node in the scheme.
"""
return self.__node_for_widget[widget]
def widget_properties(self, node):
"""
Return the current widget properties/settings.
Parameters
----------
node : SchemeNode
Returns
-------
settings : dict
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Materialized):
return state.widget.settingsHandler.pack_data(state.widget)
else:
return node.properties
def set_creation_policy(self, policy):
"""
Set the widget creation policy
Parameters
----------
policy : WidgetManager.CreationPolicy
"""
if self.__creation_policy != policy:
self.__creation_policy = policy
if self.__creation_policy == WidgetManager.Immediate:
self.__init_timer.stop()
while self.__init_queue:
state = self.__init_queue.popleft()
self.__materialize(state)
elif self.__creation_policy == WidgetManager.Normal:
if not self.__init_timer.isActive() and self.__init_queue:
self.__init_timer.start()
elif self.__creation_policy == WidgetManager.OnDemand:
self.__init_timer.stop()
else:
assert False
def creation_policy(self):
"""
Return the current widget creation policy
Returns
-------
policy: WidgetManager.CreationPolicy
"""
return self.__creation_policy
def add_widget_for_node(self, node):
"""
Create a new OWWidget instance for the corresponding scheme node.
"""
state = WidgetManager.Delayed(node)
self.__initstate_for_node[node] = state
if self.__creation_policy == WidgetManager.Immediate:
self.__initstate_for_node[node] = self.__materialize(state)
elif self.__creation_policy == WidgetManager.Normal:
self.__init_queue.append(state)
if not self.__init_timer.isActive():
self.__init_timer.start()
elif self.__creation_policy == WidgetManager.OnDemand:
self.__init_queue.append(state)
def __materialize(self, state):
# Create and initialize an OWWidget for a Delayed
# widget initialization
assert isinstance(state, WidgetManager.Delayed)
if state in self.__init_queue:
self.__init_queue.remove(state)
node = state.node
widget = self.create_widget_instance(node)
self.__widgets.append(widget)
self.__widget_for_node[node] = widget
self.__node_for_widget[widget] = node
self.__initialize_widget_state(node, widget)
state = WidgetManager.Materialized(node, widget)
self.__initstate_for_node[node] = state
self.widget_for_node_added.emit(node, widget)
return state
def remove_widget_for_node(self, node):
"""
Remove the OWWidget instance for node.
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Delayed):
del self.__initstate_for_node[node]
self.__init_queue.remove(state)
elif isinstance(state, WidgetManager.Materialized):
# Update the node's stored settings/properties dict before
# removing the widget.
# TODO: Update/sync whenever the widget settings change.
node.properties = self._widget_settings(state.widget)
self.__widgets.remove(state.widget)
del self.__initstate_for_node[node]
del self.__widget_for_node[node]
del self.__node_for_widget[state.widget]
node.title_changed.disconnect(state.widget.setCaption)
state.widget.progressBarValueChanged.disconnect(node.set_progress)
del state.widget._Report__report_view
self.widget_for_node_removed.emit(node, state.widget)
self._delete_widget(state.widget)
elif isinstance(state, WidgetManager.PartiallyInitialized):
widget = state.partially_initialized_widget
raise RuntimeError(
"A widget/node {} was removed while being initialized. "
"This is most likely a result of an explicit "
"QApplication.processEvents call from the '{}.{}' "
"widgets __init__.\n".format(state.node.title,
type(widget).__module__,
type(widget).__init__))
def _widget_settings(self, widget):
return widget.settingsHandler.pack_data(widget)
def _delete_widget(self, widget):
"""
Delete the OWBaseWidget instance.
"""
widget.close()
# Save settings to user global settings.
widget.saveSettings()
# Notify the widget it will be deleted.
widget.onDeleteWidget()
state = self.__widget_processing_state[widget]
if state & WidgetManager._DelayDeleteMask:
# If the widget is in an update loop and/or blocking we
# delay the scheduled deletion until the widget is done.
log.debug(
"Widget %s removed but still in state :%s. "
"Deferring deletion.", widget, state)
self.__delay_delete.add(widget)
else:
widget.deleteLater()
del self.__widget_processing_state[widget]
def create_widget_instance(self, node):
"""
Create a OWWidget instance for the node.
"""
desc = node.description
klass = widget = None
initialized = False
error = None
# First try to actually retrieve the class.
try:
klass = name_lookup(desc.qualified_name)
except (ImportError, AttributeError):
sys.excepthook(*sys.exc_info())
error = "Could not import {0!r}\n\n{1}".format(
node.description.qualified_name, traceback.format_exc())
except Exception:
sys.excepthook(*sys.exc_info())
error = "An unexpected error during import of {0!r}\n\n{1}".format(
node.description.qualified_name, traceback.format_exc())
if klass is None:
widget = mock_error_owwidget(node, error)
initialized = True
if widget is None:
log.info("WidgetManager: Creating '%s.%s' instance '%s'.",
klass.__module__, klass.__name__, node.title)
widget = klass.__new__(
klass,
None,
captionTitle=node.title,
signal_manager=self.signal_manager(),
stored_settings=node.properties,
# NOTE: env is a view of the real env and reflects
# changes to the environment.
env=self.scheme().runtime_env())
initialized = False
# Init the node/widget mapping and state before calling __init__
# Some OWWidgets might already send data in the constructor
# (should this be forbidden? Raise a warning?) triggering the signal
# manager which would request the widget => node mapping or state
# Furthermore they can (though they REALLY REALLY REALLY should not)
# explicitly call qApp.processEvents.
assert node not in self.__widget_for_node
self.__widget_for_node[node] = widget
self.__node_for_widget[widget] = node
self.__widget_processing_state[widget] = WidgetManager.Initializing
self.__initstate_for_node[node] = \
WidgetManager.PartiallyInitialized(node, widget)
if not initialized:
try:
widget.__init__()
except Exception:
sys.excepthook(*sys.exc_info())
msg = traceback.format_exc()
msg = "Could not create {0!r}\n\n{1}".format(
node.description.name, msg)
# remove state tracking for widget ...
del self.__widget_for_node[node]
del self.__node_for_widget[widget]
del self.__widget_processing_state[widget]
# ... and substitute it with a mock error widget.
widget = mock_error_owwidget(node, msg)
self.__widget_for_node[node] = widget
self.__node_for_widget[widget] = node
self.__widget_processing_state[widget] = 0
self.__initstate_for_node[node] = \
WidgetManager.Materialized(node, widget)
self.__initstate_for_node[node] = \
WidgetManager.Materialized(node, widget)
# Clear Initializing flag
self.__widget_processing_state[widget] &= ~WidgetManager.Initializing
node.title_changed.connect(widget.setCaption)
# Widget's info/warning/error messages.
widget.messageActivated.connect(self.__on_widget_state_changed)
widget.messageDeactivated.connect(self.__on_widget_state_changed)
# Widget's statusTip
node.set_status_message(widget.statusMessage())
widget.statusMessageChanged.connect(node.set_status_message)
# Widget's progress bar value state.
widget.progressBarValueChanged.connect(node.set_progress)
# Widget processing state (progressBarInit/Finished)
# and the blocking state.
widget.processingStateChanged.connect(
self.__on_processing_state_changed)
widget.blockingStateChanged.connect(self.__on_blocking_state_changed)
if widget.isBlocking():
# A widget can already enter blocking state in __init__
self.__widget_processing_state[widget] |= self.BlockingUpdate
if widget.processingState != 0:
# It can also start processing (initialization of resources, ...)
self.__widget_processing_state[widget] |= self.ProcessingUpdate
node.set_processing_state(1)
node.set_progress(widget.progressBarValue)
# Install a help shortcut on the widget
help_action = widget.findChild(QAction, "action-help")
if help_action is not None:
help_action.setEnabled(True)
help_action.setVisible(True)
help_action.triggered.connect(self.__on_help_request)
# Up shortcut (activate/open parent)
up_shortcut = QShortcut(QKeySequence(Qt.ControlModifier + Qt.Key_Up),
widget)
up_shortcut.activated.connect(self.__on_activate_parent)
# Call setters only after initialization.
widget.setWindowIcon(icon_loader.from_description(desc).get(desc.icon))
widget.setCaption(node.title)
# befriend class Report
widget._Report__report_view = self.scheme().report_view
self.__set_float_on_top_flag(widget)
# Schedule an update with the signal manager, due to the cleared
# implicit Initializing flag
self.signal_manager()._update()
return widget
def node_processing_state(self, node):
"""
Return the processing state flags for the node.
Same as `manager.widget_processing_state(manger.widget_for_node(node))`
"""
state = self.__initstate_for_node[node]
if isinstance(state, WidgetManager.Materialized):
return self.__widget_processing_state[state.widget]
elif isinstance(state, WidgetManager.PartiallyInitialized):
return self.__widget_processing_state[
state.partially_initialized_widget]
else:
return WidgetManager.Initializing
def widget_processing_state(self, widget):
"""
Return the processing state flags for the widget.
The state is an bitwise or of `InputUpdate` and `BlockingUpdate`.
"""
return self.__widget_processing_state[widget]
def set_float_widgets_on_top(self, float_on_top):
"""
Set `Float Widgets on Top` flag on all widgets.
"""
self.__float_widgets_on_top = float_on_top
for widget in self.__widget_for_node.values():
self.__set_float_on_top_flag(widget)
def __create_delayed(self):
if self.__init_queue:
state = self.__init_queue.popleft()
node = state.node
self.__initstate_for_node[node] = self.__materialize(state)
if self.__creation_policy == WidgetManager.Normal and \
self.__init_queue:
# restart the timer if pending widgets still in the queue
self.__init_timer.start()
def eventFilter(self, receiver, event):
if event.type() == QEvent.Close and receiver is self.__scheme:
self.signal_manager().stop()
# Notify the widget instances.
for widget in list(self.__widget_for_node.values()):
widget.close()
widget.saveSettings()
widget.onDeleteWidget()
widget.deleteLater()
return QObject.eventFilter(self, receiver, event)
def __on_help_request(self):
"""
Help shortcut was pressed. We send a `QWhatsThisClickedEvent` to
the scheme and hope someone responds to it.
"""
# Sender is the QShortcut, and parent the OWBaseWidget
widget = self.sender().parent()
try:
node = self.node_for_widget(widget)
except KeyError:
pass
else:
qualified_name = node.description.qualified_name
help_url = "help://search?" + urlencode({"id": qualified_name})
event = QWhatsThisClickedEvent(help_url)
QCoreApplication.sendEvent(self.scheme(), event)
def __on_activate_parent(self):
"""
Activate parent shortcut was pressed.
"""
event = ActivateParentEvent()
QCoreApplication.sendEvent(self.scheme(), event)
def __initialize_widget_state(self, node, widget):
"""
Initialize the tracked info/warning/error message state.
"""
for message_group in widget.message_groups:
message = user_message_from_state(message_group)
if message:
node.set_state_message(message)
def __on_widget_state_changed(self, msg):
"""
The OWBaseWidget info/warning/error state has changed.
"""
widget = msg.group.widget
try:
node = self.node_for_widget(widget)
except KeyError:
pass
else:
self.__initialize_widget_state(node, widget)
def __on_processing_state_changed(self, state):
"""
A widget processing state has changed (progressBarInit/Finished)
"""
widget = self.sender()
if state:
self.__widget_processing_state[widget] |= self.ProcessingUpdate
else:
self.__widget_processing_state[widget] &= ~self.ProcessingUpdate
# propagate the change to the workflow model.
try:
# we can still track widget state after it was removed from the
# workflow model (`__delay_delete`)
node = self.node_for_widget(widget)
except KeyError:
pass
else:
self.__update_node_processing_state(node)
def __on_processing_started(self, node):
"""
Signal manager entered the input update loop for the node.
"""
widget = self.widget_for_node(node)
# Remember the widget instance. The node and the node->widget mapping
# can be removed between this and __on_processing_finished.
self.__updating_widget = widget
self.__widget_processing_state[widget] |= self.InputUpdate
self.__update_node_processing_state(node)
def __on_processing_finished(self, node):
"""
Signal manager exited the input update loop for the node.
"""
widget = self.__updating_widget
self.__widget_processing_state[widget] &= ~self.InputUpdate
if widget in self.__node_for_widget:
self.__update_node_processing_state(node)
elif widget in self.__delay_delete:
self.__try_delete(widget)
else:
raise ValueError("%r is not managed" % widget)
self.__updating_widget = None
def __on_blocking_state_changed(self, state):
"""
OWWidget blocking state has changed.
"""
if not state:
# schedule an update pass.
self.signal_manager()._update()
widget = self.sender()
if state:
self.__widget_processing_state[widget] |= self.BlockingUpdate
else:
self.__widget_processing_state[widget] &= ~self.BlockingUpdate
if widget in self.__node_for_widget:
node = self.node_for_widget(widget)
self.__update_node_processing_state(node)
elif widget in self.__delay_delete:
self.__try_delete(widget)
def __update_node_processing_state(self, node):
"""
Update the `node.processing_state` to reflect the widget state.
"""
state = self.node_processing_state(node)
node.set_processing_state(1 if state else 0)
def __try_delete(self, widget):
if not (self.__widget_processing_state[widget]
& WidgetManager._DelayDeleteMask):
log.debug("Delayed delete for widget %s", widget)
self.__delay_delete.remove(widget)
del self.__widget_processing_state[widget]
widget.blockingStateChanged.disconnect(
self.__on_blocking_state_changed)
widget.processingStateChanged.disconnect(
self.__on_processing_state_changed)
widget.deleteLater()
def __on_env_changed(self, key, newvalue, oldvalue):
# Notify widgets of a runtime environment change
for widget in self.__widget_for_node.values():
widget.workflowEnvChanged(key, newvalue, oldvalue)
def __set_float_on_top_flag(self, widget):
"""Set or unset widget's float on top flag"""
should_float_on_top = self.__float_widgets_on_top
if hasattr(qApp, "applicationState"):
# only float on top when the application is active
# available in Qt >= 5.2
should_float_on_top &= qApp.applicationState(
) == Qt.ApplicationActive
float_on_top = widget.windowFlags() & Qt.WindowStaysOnTopHint
if float_on_top == should_float_on_top:
return
widget_was_visible = widget.isVisible()
if should_float_on_top:
widget.setWindowFlags(Qt.WindowStaysOnTopHint)
else:
widget.setWindowFlags(widget.windowFlags()
& ~Qt.WindowStaysOnTopHint)
# Changing window flags hid the widget
if widget_was_visible:
widget.show()
class RotaryEncoderModuleGUI(RotaryEncoderModule, BaseWidget):
TITLE = 'Rotary encoder module'
def __init__(self, parent_win=None):
BaseWidget.__init__(self, self.TITLE, parent_win=parent_win)
RotaryEncoderModule.__init__(self)
self._port = ControlCombo(
'Serial port', changed_event=self.__combo_serial_ports_changed_evt)
self._refresh_serial_ports = ControlButton(
'',
icon=QtGui.QIcon(conf.REFRESH_SMALL_ICON),
default=self.__refresh_serial_ports_btn_pressed,
helptext="Press here to refresh the list of available devices.")
self._connect_btn = ControlButton('Connect', checkable=True)
self._filename = ControlText('Stream Filename', '')
self._saveas_btn = ControlButton('Save As...')
self._events = ControlCheckBox('Enable events')
self._output_stream = ControlCheckBox('Output stream')
self._stream = ControlCheckBox('Stream data')
self._stream_file = ControlCheckBox('Stream to file')
self._zero_btn = ControlButton('Reset position')
self._start_reading = ControlButton('Start Reading')
self._reset_threshs = ControlButton('Reset thresholds')
self._thresh_lower = ControlNumber('Lower threshold (deg)',
0,
minimum=-360,
maximum=360)
self._thresh_upper = ControlNumber('Upper threshold (deg)',
0,
minimum=-360,
maximum=360)
self._graph = ControlMatplotlib('Value')
self._clear_btn = ControlButton('Clear')
self.set_margin(10)
self.formset = [('_port', '_refresh_serial_ports', '_connect_btn'),
('_filename', '_saveas_btn'),
('_events', '_output_stream', '_stream',
'_stream_file', '_zero_btn'), '_start_reading',
('_thresh_lower', '_thresh_upper', '_reset_threshs'),
'=', '_graph', '_clear_btn']
self._stream.enabled = False
self._stream_file.enabled = False
self._events.enabled = False
self._output_stream.enabled = False
self._zero_btn.enabled = False
self._reset_threshs.enabled = False
self._thresh_lower.enabled = False
self._thresh_upper.enabled = False
self._start_reading.enabled = False
self._connect_btn.value = self.__toggle_connection_evt
self._saveas_btn.value = self.__prompt_savig_evt
self._stream_file.changed_event = self.__stream_file_changed_evt
self._events.changed_event = self.__events_changed_evt
self._output_stream.changed_event = self.__output_stream_changed_evt
self._thresh_upper.changed_event = self.__thresh_evt
self._thresh_lower.changed_event = self.__thresh_evt
self._reset_threshs.value = self.__reset_thresholds_evt
self._zero_btn.value = self.__zero_btn_evt
self._start_reading.value = self.__start_reading_evt
self._graph.on_draw = self.__on_draw_evt
self._clear_btn.value = self.__clear_btn_evt
self._filename.changed_event = self.__filename_changed_evt
self.history_x = []
self.history_y = []
self._timer = QTimer()
self._timer.timeout.connect(self.__update_readings)
self._fill_serial_ports()
def _fill_serial_ports(self):
self._port.add_item('', '')
for n, port in enumerate(sorted(serial.tools.list_ports.comports()),
1):
self._port.add_item("{device}".format(device=port.device),
str(port.device))
def __filename_changed_evt(self):
if not self._filename.value:
self._stream_file.value = False
self._stream_file.enabled = False
def __prompt_savig_evt(self):
'''
Opens a window for user to select where to save the csv file
'''
self._filename.value, _ = QFileDialog.getSaveFileName()
if self._filename.value:
self._stream_file.enabled = True
else:
self._stream_file.value = False
self._stream_file.enabled = False
def __stream_file_changed_evt(self):
'''
User wants to store rotary encoder measurements in a CSV file. Create it
'''
if self._stream_file.value is True:
self._csvfile = open(self._filename.value, 'w')
self._csvwriter = csv.writer(
self._csvfile,
def_text=
'This file has all the rotary encoder data recorded during a PyBpod session.',
columns_headers=['PC_TIME', 'DATA_TYPE', 'EVT_TIME', 'VALUE'
]) # Check if we need something else after
def __start_reading_evt(self):
'''
Toggle timer
'''
if self._timer.isActive():
self.disable_stream()
self._start_reading.label = 'Start Reading'
self._timer.stop()
else:
self.enable_stream()
self.history_x = []
self.history_y = []
self._start_reading.label = 'Stop Reading'
self._timer.start(30)
def __clear_btn_evt(self):
'''
Clear recorded data
'''
self.history_x = []
self.history_y = []
self._graph.draw()
def __on_draw_evt(self, figure):
'''
The actual draw function. Pick just the last 200 measurements in order to avoid app freezing
'''
axes = figure.add_subplot(111)
axes.clear()
totallen = len(self.history_x)
if totallen > 200:
x = self.history_x[totallen - 201:]
y = self.history_y[totallen - 201:]
axes.plot(x, y)
if len(x) >= 2:
x_range = [x[0], x[-1]]
axes.plot(x_range,
[self._thresh_upper.value, self._thresh_upper.value],
linestyle='dotted',
color='red')
axes.plot(x_range,
[self._thresh_lower.value, self._thresh_lower.value],
linestyle='dotted',
color='blue')
else:
axes.plot(self.history_x, self.history_y)
if len(self.history_x) >= 2:
x_range = [self.history_x[0], self.history_x[-1]]
axes.plot(x_range,
[self._thresh_upper.value, self._thresh_upper.value],
linestyle='dotted',
color='red')
axes.plot(x_range,
[self._thresh_lower.value, self._thresh_lower.value],
linestyle='dotted',
color='blue')
self._graph.repaint()
def __update_graph(self, readings):
'''
Add new data to the reading history and update the graph
'''
for data in readings:
if data[0] == 'P':
self.history_x.append(data[1])
self.history_y.append(data[2])
self._graph.draw()
def __update_readings(self):
'''
Get new measurements and channel them to the graph or the file being written
'''
data = self.read_stream()
if self._stream.value:
self.__update_graph(data)
if self._stream_file.value:
self.__write_to_file(data)
def __write_to_file(self, readings):
'''
Write new readings to the file
'''
now = datetime_now.now()
for data in readings:
self._csvwriter.writerow([now.strftime('%Y%m%d%H%M%S')] + data)
def __zero_btn_evt(self):
self.set_zero_position()
def __reset_thresholds_evt(self):
self._thresh_lower.value = 0
self._thresh_upper.value = 0
def __thresh_evt(self):
thresholds = [
int(self._thresh_lower.value),
int(self._thresh_upper.value)
]
self.set_thresholds(thresholds)
def __events_changed_evt(self):
if self._stream.value:
self.enable_evt_transmission()
else:
self.disable_evt_transmission()
def __output_stream_changed_evt(self):
if self._stream.value:
self.enable_module_outputstream()
else:
self.disable_module_outputstream()
def __toggle_connection_evt(self):
if not self._connect_btn.checked:
if hasattr(self, 'arcom'):
self.disable_stream()
self._timer.stop()
self.close()
self._connect_btn.label = 'Connect'
self._stream.enabled = False
self._events.enabled = False
self._output_stream.enabled = False
self._zero_btn.enabled = False
self._reset_threshs.enabled = False
self._thresh_lower.enabled = False
self._thresh_upper.enabled = False
self._start_reading.enabled = False
self._stream_file.enabled = False
self._port.enabled = True
self._refresh_serial_ports.enabled = True
else:
try:
self.open(self._port.value)
self._connect_btn.label = 'Disconnect'
self._stream.enabled = True
self._events.enabled = True
self._output_stream.enabled = True
self._zero_btn.enabled = True
self._reset_threshs.enabled = True
self._thresh_lower.enabled = True
self._thresh_upper.enabled = True
self._start_reading.enabled = True
self._port.enabled = False
self._refresh_serial_ports.enabled = False
if self._filename.value:
self._stream_file.enabled = True
else:
self._stream_file.value = False
self._stream_file.enabled = False
except Exception as err:
self.critical(str(err), "Error")
self._connect_btn.checked = False
def __combo_serial_ports_changed_evt(self):
self._connect_btn.enabled = True
def __refresh_serial_ports_btn_pressed(self):
tmp = self._port.value
self._port.clear()
self._fill_serial_ports()
self._port.value = tmp
class SignalManager(QObject):
"""
SignalManager handles the runtime signal propagation for a :class:`.Scheme`
instance.
Note
----
If a scheme instance is passed as a parent to the constructor it is also
set as the workflow model.
"""
class State(enum.IntEnum):
"""
SignalManager state flags.
.. seealso:: :func:`SignalManager.state()`
"""
#: The manager is running, i.e. it propagates signals
Running = 0
#: The manager is stopped. It does not track node output changes,
#: and does not deliver signals to dependent nodes
Stopped = 1
#: The manager is paused. It still tracks node output changes, but
#: does not deliver new signals to dependent nodes. The pending signals
#: will be delivered once it enters Running state again
Paused = 2
#: The manager is running, i.e. it propagates signals
Running = State.Running
#: The manager is stopped. It does not track node ouput changes,
#: and does not deliver signals to dependent nodes
Stopped = State.Stopped
#: The manager is paused. It still tracks node output changes, but
#: does not deliver new signals to dependent nodes. The pending signals
#: will be delivered once it enters Running state again
Paused = State.Paused
# unused; back-compatibility
Error = 3
class RuntimeState(enum.IntEnum):
"""
SignalManager runtime state.
See Also
--------
SignalManager.runtime_state
"""
#: Waiting, idle state. The signal queue is empty
Waiting = 0
#: ...
Processing = 1
Waiting = RuntimeState.Waiting
Processing = RuntimeState.Processing
#: Emitted when the state of the signal manager changes.
stateChanged = pyqtSignal(int)
#: Emitted when signals are added to the queue.
updatesPending = pyqtSignal()
#: Emitted right before a `SchemeNode` instance has its inputs updated.
processingStarted = pyqtSignal([], [SchemeNode])
#: Emitted right after a `SchemeNode` instance has had its inputs updated.
processingFinished = pyqtSignal([], [SchemeNode])
#: Emitted when `SignalManager`'s runtime state changes.
runtimeStateChanged = pyqtSignal(int)
def __init__(self, parent=None, *, max_running=None, **kwargs):
# type: (Optional[QObject], Optional[int], Any) -> None
super().__init__(parent, **kwargs)
self.__workflow = None # type: Optional[Scheme]
self.__input_queue = [] # type: List[Signal]
# mapping a node to its current outputs
self.__node_outputs = {
} # type: Dict[SchemeNode, DefaultDict[OutputSignal, _OutputState]]
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
self.__max_running = max_running
if isinstance(parent, Scheme):
self.set_workflow(parent)
def _can_process(self): # type: () -> bool
"""
Return a bool indicating if the manger can enter the main
processing loop.
"""
return self.__state not in [SignalManager.Error, SignalManager.Stopped]
def workflow(self):
# type: () -> Optional[Scheme]
"""
Return the :class:`Scheme` instance.
"""
return self.__workflow
#: Alias
scheme = workflow
def set_workflow(self, workflow):
# type: (Scheme) -> None
"""
Set the workflow model.
Parameters
----------
workflow : Scheme
"""
if workflow is self.__workflow:
return
if self.__workflow is not None:
for node in self.__workflow.nodes:
node.state_changed.disconnect(self._update)
for link in self.__workflow.links:
link.enabled_changed.disconnect(self.__on_link_enabled_changed)
self.__workflow.node_added.disconnect(self.__on_node_added)
self.__workflow.node_removed.disconnect(self.__on_node_removed)
self.__workflow.link_added.disconnect(self.__on_link_added)
self.__workflow.link_removed.disconnect(self.__on_link_removed)
self.__workflow.removeEventFilter(self)
self.__node_outputs = {}
self.__input_queue = []
self.__workflow = workflow
if workflow is not None:
workflow.node_added.connect(self.__on_node_added)
workflow.node_removed.connect(self.__on_node_removed)
workflow.link_added.connect(self.__on_link_added)
workflow.link_removed.connect(self.__on_link_removed)
for node in workflow.nodes:
self.__node_outputs[node] = defaultdict(_OutputState)
node.state_changed.connect(self._update)
for link in workflow.links:
link.enabled_changed.connect(self.__on_link_enabled_changed)
workflow.installEventFilter(self)
def has_pending(self): # type: () -> bool
"""
Does the manager have any signals to deliver?
"""
return bool(self.__input_queue)
def start(self): # type: () -> None
"""
Start the update loop.
Note
----
The updates will not happen until the control reaches the Qt event
loop.
"""
if self.__state != SignalManager.Running:
self.__state = SignalManager.Running
self.stateChanged.emit(SignalManager.Running)
self._update()
def stop(self): # type: () -> None
"""
Stop the update loop.
Note
----
If the `SignalManager` is currently in `process_queues` it will
still update all current pending signals, but will not re-enter
until `start()` is called again.
"""
if self.__state != SignalManager.Stopped:
self.__state = SignalManager.Stopped
self.stateChanged.emit(SignalManager.Stopped)
self.__update_timer.stop()
def pause(self): # type: () -> None
"""
Pause the delivery of signals.
"""
if self.__state != SignalManager.Paused:
self.__state = SignalManager.Paused
self.stateChanged.emit(SignalManager.Paused)
self.__update_timer.stop()
def resume(self):
# type: () -> None
"""
Resume the delivery of signals.
"""
if self.__state == SignalManager.Paused:
self.__state = SignalManager.Running
self.stateChanged.emit(self.__state)
self._update()
def step(self):
# type: () -> None
"""
Deliver signals to a single node (only applicable while the `state()`
is `Paused`).
"""
if self.__state == SignalManager.Paused:
self.process_queued()
def state(self):
# type: () -> State
"""
Return the current state.
Return
------
state : SignalManager.State
"""
return self.__state
def _set_runtime_state(self, state):
# type: (Union[RuntimeState, int]) -> None
"""
Set the runtime state.
Should only be called by `SignalManager` implementations.
"""
if self.__runtime_state != state:
self.__runtime_state = state
self.runtimeStateChanged.emit(self.__runtime_state)
def runtime_state(self):
# type: () -> RuntimeState
"""
Return the runtime state. This can be `SignalManager.Waiting`
or `SignalManager.Processing`.
"""
return self.__runtime_state
def __on_node_removed(self, node):
# type: (SchemeNode) -> None
# remove all pending input signals for node so we don't get
# stale references in process_node.
# NOTE: This does not remove output signals for this node. In
# particular the final 'None' will be delivered to the sink
# nodes even after the source node is no longer in the scheme.
log.info("Removing pending signals for '%s'.", node.title)
self.remove_pending_signals(node)
del self.__node_outputs[node]
node.state_changed.disconnect(self._update)
def __on_node_added(self, node):
# type: (SchemeNode) -> None
self.__node_outputs[node] = defaultdict(_OutputState)
# schedule update pass on state change
node.state_changed.connect(self._update)
def __on_link_added(self, link):
# type: (SchemeLink) -> None
# push all current source values to the sink
link.set_runtime_state(SchemeLink.Empty)
state = self.__node_outputs[link.source_node][link.source_channel]
link.set_runtime_state_flag(
SchemeLink.Invalidated,
bool(state.flags & _OutputState.Invalidated))
if link.enabled:
log.info("Scheduling signal data update for '%s'.", link)
self._schedule(self.signals_on_link(link))
self._update()
link.enabled_changed.connect(self.__on_link_enabled_changed)
def __on_link_removed(self, link):
# type: (SchemeLink) -> None
# purge all values in sink's queue
log.info("Scheduling signal data purge (%s).", link)
self.purge_link(link)
link.enabled_changed.disconnect(self.__on_link_enabled_changed)
def __on_link_enabled_changed(self, enabled):
if enabled:
link = self.sender()
log.info("Link %s enabled. Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
def signals_on_link(self, link):
# type: (SchemeLink) -> List[Signal]
"""
Return :class:`Signal` instances representing the current values
present on the `link`.
"""
items = self.link_contents(link)
signals = []
for key, value in items.items():
signals.append(Signal(link, value, key))
return signals
def link_contents(self, link):
# type: (SchemeLink) -> Dict[Any, Any]
"""
Return the contents on the `link`.
"""
node, channel = link.source_node, link.source_channel
if node in self.__node_outputs:
return self.__node_outputs[node][channel].outputs
else:
# if the the node was already removed its tracked outputs in
# __node_outputs are cleared, however the final 'None' signal
# deliveries for the link are left in the _input_queue.
pending = [sig for sig in self.__input_queue if sig.link is link]
return {sig.id: sig.value for sig in pending}
def send(self, node, channel, value, id):
# type: (SchemeNode, OutputSignal, Any, Any) -> None
"""
Send the `value` with `id` on an output `channel` from node.
Schedule the signal delivery to all dependent nodes
Parameters
----------
node : SchemeNode
The originating node.
channel : OutputSignal
The nodes output on which the value is sent.
value : Any
The value to send,
id : Any
Signal id.
"""
if self.__workflow is None:
raise RuntimeError("'send' called with no workflow!.")
log.debug("%r sending %r (id: %r) on channel %r", node.title,
type(value), id, channel.name)
scheme = self.__workflow
state = self.__node_outputs[node][channel]
state.outputs[id] = value
# clear invalidated flag
if state.flags & _OutputState.Invalidated:
log.debug("%r clear invalidated flag on channel %r", node.title,
channel.name)
state.flags &= ~_OutputState.Invalidated
links = filter(
is_enabled,
scheme.find_links(source_node=node, source_channel=channel))
signals = []
for link in links:
signals.append(Signal(link, value, id))
link.set_runtime_state_flag(SchemeLink.Invalidated, False)
self._schedule(signals)
def invalidate(self, node, channel):
# type: (SchemeNode, OutputSignal) -> None
"""
Invalidate the `channel` on `node`.
The channel is effectively considered changed but unavailable until
a new value is sent via `send`. While this state is set the dependent
nodes will not be updated.
All links originating with this node/channel will be marked with
`SchemeLink.Invalidated` flag until a new value is sent with `send`.
Parameters
----------
node: SchemeNode
The originating node.
channel: OutputSignal
The channel to invalidate.
.. versionadded:: 0.1.8
"""
log.debug("%r invalidating channel %r", node.title, channel.name)
self.__node_outputs[node][channel].flags |= _OutputState.Invalidated
if self.__workflow is None:
return
links = self.__workflow.find_links(source_node=node,
source_channel=channel)
for link in links:
link.set_runtime_state(link.runtime_state() | link.Invalidated)
def purge_link(self, link):
# type: (SchemeLink) -> None
"""
Purge the link (send None for all ids currently present)
"""
contents = self.link_contents(link)
ids = contents.keys()
signals = [Signal(link, None, id) for id in ids]
self._schedule(signals)
def _schedule(self, signals):
# type: (List[Signal]) -> None
"""
Schedule a list of :class:`Signal` for delivery.
"""
self.__input_queue.extend(signals)
for link in {sig.link for sig in signals}:
# update the SchemeLink's runtime state flags
contents = self.link_contents(link)
if any(value is not None for value in contents.values()):
state = SchemeLink.Active
else:
state = SchemeLink.Empty
link.set_runtime_state(state | SchemeLink.Pending)
for node in {sig.link.sink_node
for sig in signals}: # type: SchemeNode
# update the SchemeNodes's runtime state flags
node.set_state_flags(SchemeNode.Pending, True)
if signals:
self.updatesPending.emit()
self._update()
def _update_link(self, link):
# type: (SchemeLink) -> None
"""
Schedule update of a single link.
"""
signals = self.signals_on_link(link)
self._schedule(signals)
def process_queued(self, max_nodes=None):
# type: (Any) -> None
"""
Process queued signals.
Take the first eligible node from the pending input queue and deliver
all scheduled signals.
"""
if not (max_nodes is None or max_nodes == 1):
warnings.warn(
"`max_nodes` is deprecated and will be removed in the future",
FutureWarning,
stacklevel=2)
if self.__runtime_state == SignalManager.Processing:
raise RuntimeError("Cannot re-enter 'process_queued'")
if not self._can_process():
raise RuntimeError("Can't process in state %i" % self.__state)
self.process_next()
def process_next(self):
# type: () -> bool
"""
Process queued signals.
Take the first eligible node from the pending input queue and deliver
all scheduled signals for it and return `True`.
If no node is eligible for update do nothing and return `False`.
"""
return self.__process_next_helper(use_max_active=False)
def process_node(self, node):
# type: (SchemeNode) -> None
"""
Process pending input signals for `node`.
"""
assert self.__runtime_state != SignalManager.Processing
signals_in = self.pending_input_signals(node)
self.remove_pending_signals(node)
signals_in = self.compress_signals(signals_in)
log.debug("Processing %r, sending %i signals.", node.title,
len(signals_in))
# Clear the link's pending flag.
for link in {sig.link for sig in signals_in}:
link.set_runtime_state(link.runtime_state() & ~SchemeLink.Pending)
def process_dynamic(signals):
# type: (List[Signal]) -> List[Signal]
"""
Process dynamic signals; Update the link's dynamic_enabled flag if
the value is valid; replace values that do not type check with
`None`
"""
res = []
for sig in signals:
# Check and update the dynamic link state
link = sig.link
if sig.link.is_dynamic():
enabled = can_enable_dynamic(link, sig.value)
link.set_dynamic_enabled(enabled)
if not enabled:
# Send None instead (clear the link)
sig = Signal(link, None, sig.id)
res.append(sig)
return res
signals_in = process_dynamic(signals_in)
assert ({sig.link
for sig in self.__input_queue
}.intersection({sig.link
for sig in signals_in}) == set([]))
self._set_runtime_state(SignalManager.Processing)
self.processingStarted.emit()
self.processingStarted[SchemeNode].emit(node)
try:
self.send_to_node(node, signals_in)
finally:
node.set_state_flags(SchemeNode.Pending, False)
self.processingFinished.emit()
self.processingFinished[SchemeNode].emit(node)
self._set_runtime_state(SignalManager.Waiting)
def compress_signals(self, signals):
# type: (List[Signal]) -> List[Signal]
"""
Compress a list of :class:`Signal` instances to be delivered.
Before the signal values are delivered to the sink node they can be
optionally `compressed`, i.e. values can be merged or dropped
depending on the execution semantics.
The input list is in the order that the signals were enqueued.
The base implementation returns the list unmodified.
Parameters
----------
signals : List[Signal]
Return
------
signals : List[Signal]
"""
return signals
def send_to_node(self, node, signals):
# type: (SchemeNode, List[Signal]) -> None
"""
Abstract. Reimplement in subclass.
Send/notify the `node` instance (or whatever object/instance it is a
representation of) that it has new inputs as represented by the
`signals` list).
Parameters
----------
node : SchemeNode
signals : List[Signal]
"""
raise NotImplementedError
def is_pending(self, node):
# type: (SchemeNode) -> bool
"""
Is `node` (class:`SchemeNode`) scheduled for processing (i.e.
it has incoming pending signals).
Parameters
----------
node : SchemeNode
Returns
-------
pending : bool
"""
return node in [signal.link.sink_node for signal in self.__input_queue]
def pending_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of pending nodes.
The nodes are returned in the order they were enqueued for
signal delivery.
Returns
-------
nodes : List[SchemeNode]
"""
return list(unique(sig.link.sink_node for sig in self.__input_queue))
def pending_input_signals(self, node):
# type: (SchemeNode) -> List[Signal]
"""
Return a list of pending input signals for node.
"""
return [
signal for signal in self.__input_queue
if node is signal.link.sink_node
]
def remove_pending_signals(self, node):
# type: (SchemeNode) -> None
"""
Remove pending signals for `node`.
"""
for signal in self.pending_input_signals(node):
try:
self.__input_queue.remove(signal)
except ValueError:
pass
def __nodes(self):
# type: () -> Sequence[SchemeNode]
return self.__workflow.nodes if self.__workflow else []
def blocking_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of nodes in a blocking state.
"""
return [node for node in self.__nodes() if self.is_blocking(node)]
def invalidated_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of invalidated nodes.
.. versionadded:: 0.1.8
"""
return [
node for node in self.__nodes()
if self.has_invalidated_outputs(node) or self.is_invalidated(node)
]
def active_nodes(self):
# type: () -> List[SchemeNode]
"""
Return a list of active nodes.
.. versionadded:: 0.1.8
"""
return [node for node in self.__nodes() if self.is_active(node)]
def is_blocking(self, node):
# type: (SchemeNode) -> bool
"""
Is the node in `blocking` state.
Is it currently in a state where will produce new outputs and
therefore no signals should be delivered to dependent nodes until
it does so. Also no signals will be delivered to the node until
it exits this state.
The default implementation returns False.
.. deprecated:: 0.1.8
Use a combination of `is_invalidated` and `is_ready`.
"""
return False
def is_ready(self, node: SchemeNode) -> bool:
"""
Is the node in a state where it can receive inputs.
Re-implement this method in as subclass to prevent specific nodes from
being considered for input update (e.g. they are still initializing
runtime resources, executing a non-interruptable task, ...)
Note that whenever the implicit state changes the
`post_update_request` should be called.
The default implementation returns the state of the node's
`SchemeNode.NotReady` flag.
Parameters
----------
node: SchemeNode
"""
return not node.test_state_flags(SchemeNode.NotReady)
def is_invalidated(self, node: SchemeNode) -> bool:
"""
Is the node marked as invalidated.
Parameters
----------
node : SchemeNode
Returns
-------
state: bool
"""
return node.test_state_flags(SchemeNode.Invalidated)
def has_invalidated_outputs(self, node):
# type: (SchemeNode) -> bool
"""
Does node have any explicitly invalidated outputs.
Parameters
----------
node: SchemeNode
Returns
-------
state: bool
See also
--------
invalidate
.. versionadded:: 0.1.8
"""
out = self.__node_outputs.get(node)
if out is not None:
return any(state.flags & _OutputState.Invalidated
for state in out.values())
else:
return False
def has_invalidated_inputs(self, node):
# type: (SchemeNode) -> bool
"""
Does the node have any immediate ancestor with invalidated outputs.
Parameters
----------
node : SchemeNode
Returns
-------
state: bool
Note
----
The node's ancestors are only computed over enabled links.
.. versionadded:: 0.1.8
"""
if self.__workflow is None:
return False
workflow = self.__workflow
return any(
self.has_invalidated_outputs(link.source_node)
for link in workflow.find_links(sink_node=node)
if link.is_enabled())
def is_active(self, node):
# type: (SchemeNode) -> bool
"""
Is the node considered active (executing a task).
Parameters
----------
node: SchemeNode
Returns
-------
active: bool
"""
return bool(node.state() & SchemeNode.Running)
def node_update_front(self):
# type: () -> Sequence[SchemeNode]
"""
Return a list of nodes on the update front, i.e. nodes scheduled for
an update that have no ancestor which is either itself scheduled
for update or is in a blocking state).
Note
----
The node's ancestors are only computed over enabled links.
"""
if self.__workflow is None:
return []
workflow = self.__workflow
expand = partial(expand_node, workflow)
components = strongly_connected_components(workflow.nodes, expand)
node_scc = {node: scc for scc in components for node in scc}
def isincycle(node): # type: (SchemeNode) -> bool
return len(node_scc[node]) > 1
def dependents(node): # type: (SchemeNode) -> List[SchemeNode]
return dependent_nodes(workflow, node)
# A list of all nodes currently active/executing a non-interruptable
# task.
blocking_nodes = set(self.blocking_nodes())
# nodes marked as having invalidated outputs (not yet available)
invalidated_nodes = set(self.invalidated_nodes())
#: transitive invalidated nodes (including the legacy self.is_blocked
#: behaviour - blocked nodes are both invalidated and cannot receive
#: new inputs)
invalidated_ = reduce(
set.union,
map(dependents, invalidated_nodes | blocking_nodes),
set([]),
) # type: Set[SchemeNode]
pending = self.pending_nodes()
pending_ = set()
for n in pending:
depend = set(dependents(n))
if isincycle(n):
# a pending node in a cycle would would have a circular
# dependency on itself, preventing any progress being made
# by the workflow execution.
cc = node_scc[n]
depend -= set(cc)
pending_.update(depend)
def has_invalidated_ancestor(node): # type: (SchemeNode) -> bool
return node in invalidated_
def has_pending_ancestor(node): # type: (SchemeNode) -> bool
return node in pending_
#: nodes that are eligible for update.
ready = list(
filter(
lambda node: not has_pending_ancestor(node) and
not has_invalidated_ancestor(node) and not self.is_blocking(
node), pending))
return ready
@Slot()
def __process_next(self):
if not self.__state == SignalManager.Running:
log.debug("Received 'UpdateRequest' while not in 'Running' state")
return
if self.__runtime_state == SignalManager.Processing:
# This happens if QCoreApplication.processEvents is called from
# the input handlers. A `__process_next` must be rescheduled when
# exiting process_queued.
log.warning("Received 'UpdateRequest' while in 'process_queued'. "
"An update will be re-scheduled when exiting the "
"current update.")
return
if not self.__input_queue:
return
if self.__process_next_helper(use_max_active=True):
# Schedule another update (will be a noop if nothing to do).
self._update()
def __process_next_helper(self, use_max_active=True) -> bool:
eligible = [n for n in self.node_update_front() if self.is_ready(n)]
if not eligible:
return False
max_active = self.max_active()
nactive = len(set(self.active_nodes()) | set(self.blocking_nodes()))
log.debug(
"Process next, queued signals: %i, nactive: %i "
"(max_active: %i)", len(self.__input_queue), nactive, max_active)
_ = lambda nodes: list(map(attrgetter('title'), nodes))
log.debug("Pending nodes: %s", _(self.pending_nodes()))
log.debug("Blocking nodes: %s", _(self.blocking_nodes()))
log.debug("Invalidated nodes: %s", _(self.invalidated_nodes()))
log.debug("Nodes ready for update: %s", _(eligible))
# Select an node that is already running (effectively cancelling
# already executing tasks that are immediately updatable)
selected_node = None # type: Optional[SchemeNode]
for node in eligible:
if self.is_active(node):
selected_node = node
break
# Return if over committed, except in the case that the selected_node
# is already active.
if use_max_active and nactive >= max_active and selected_node is None:
return False
if selected_node is None:
selected_node = eligible[0]
self.process_node(selected_node)
return True
def _update(self): # type: () -> None
"""
Schedule processing at a later time.
"""
if self.__state == SignalManager.Running and \
not self.__update_timer.isActive():
self.__update_timer.start()
def post_update_request(self):
"""
Schedule an update pass.
Call this method whenever:
* a node's outputs change (note that this is already done by `send`)
* any change in the node that influences its eligibility to be picked
for an input update (is_ready, is_blocking ...).
Multiple update requests are merged into one.
"""
self._update()
def set_max_active(self, val: int) -> None:
if self.__max_running != val:
self.__max_running = val
self._update()
def max_active(self) -> int:
value = self.__max_running # type: Optional[int]
if value is None:
value = mapping_get(os.environ, "MAX_ACTIVE_NODES", int, None)
if value is None:
s = QSettings()
s.beginGroup(__name__)
value = s.value("max-active-nodes", defaultValue=1, type=int)
if value < 0:
ccount = os.cpu_count()
if ccount is None:
return 1
else:
return max(1, ccount + value)
else:
return max(1, value)
class SignalManager(QObject):
"""
Handle all runtime signal propagation for a :clas:`Scheme` instance.
The scheme must be passed to the constructor and will become the parent
of this object. Furthermore this should happen before any items
(nodes, links) are added to the scheme.
"""
Running, Stoped, Paused, Error = range(4)
"""SignalManger state flags."""
Waiting, Processing = range(2)
"""SignalManager runtime state flags."""
stateChanged = Signal(int)
"""Emitted when the state of the signal manager changes."""
updatesPending = Signal()
"""Emitted when signals are added to the queue."""
processingStarted = Signal([], [SchemeNode])
"""Emitted right before a `SchemeNode` instance has its inputs
updated.
"""
processingFinished = Signal([], [SchemeNode])
"""Emitted right after a `SchemeNode` instance has had its inputs
updated.
"""
runtimeStateChanged = Signal(int)
"""Emitted when `SignalManager`'s runtime state changes."""
def __init__(self, scheme):
assert scheme
QObject.__init__(self, scheme)
self._input_queue = []
# mapping a node to it's current outputs
# {node: {channel: {id: signal_value}}}
self._node_outputs = {}
self.__state = SignalManager.Running
self.__runtime_state = SignalManager.Waiting
# A flag indicating if UpdateRequest event should be rescheduled
self.__reschedule = False
self.__update_timer = QTimer(self, interval=100, singleShot=True)
self.__update_timer.timeout.connect(self.__process_next)
def _can_process(self):
"""
Return a bool indicating if the manger can enter the main
processing loop.
"""
return self.__state not in [SignalManager.Error, SignalManager.Stoped]
def scheme(self):
"""
Return the parent class:`Scheme` instance.
"""
return self.parent()
def start(self):
"""
Start the update loop.
.. note:: The updates will not happen until the control reaches
the Qt event loop.
"""
if self.__state != SignalManager.Running:
self.__state = SignalManager.Running
self.stateChanged.emit(SignalManager.Running)
self._update()
def stop(self):
"""
Stop the update loop.
.. note:: If the `SignalManager` is currently in `process_queues` it
will still update all current pending signals, but will not
re-enter until `start()` is called again
"""
if self.__state != SignalManager.Stoped:
self.__state = SignalManager.Stoped
self.stateChanged.emit(SignalManager.Stoped)
self.__update_timer.stop()
def pause(self):
"""
Pause the updates.
"""
if self.__state != SignalManager.Paused:
self.__state = SignalManager.Paused
self.stateChanged.emit(SignalManager.Paused)
self.__update_timer.stop()
def resume(self):
if self.__state == SignalManager.Paused:
self.__state = SignalManager.Running
self.stateChanged.emit(self.__state)
self._update()
def step(self):
if self.__state == SignalManager.Paused:
self.process_queued()
def state(self):
"""
Return the current state.
"""
return self.__state
def _set_runtime_state(self, state):
"""
Set the runtime state.
Should only be called by `SignalManager` implementations.
"""
if self.__runtime_state != state:
self.__runtime_state = state
self.runtimeStateChanged.emit(self.__runtime_state)
def runtime_state(self):
"""
Return the runtime state. This can be `SignalManager.Waiting`
or `SignalManager.Processing`.
"""
return self.__runtime_state
def on_node_removed(self, node):
# remove all pending input signals for node so we don't get
# stale references in process_node.
# NOTE: This does not remove output signals for this node. In
# particular the final 'None' will be delivered to the sink
# nodes even after the source node is no longer in the scheme.
log.info("Node %r removed. Removing pending signals.", node.title)
self.remove_pending_signals(node)
del self._node_outputs[node]
def on_node_added(self, node):
self._node_outputs[node] = defaultdict(dict)
def link_added(self, link):
# push all current source values to the sink
link.set_runtime_state(SchemeLink.Empty)
if link.enabled:
log.info("Link added (%s). Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
self._update()
link.enabled_changed.connect(self.link_enabled_changed)
def link_removed(self, link):
# purge all values in sink's queue
log.info("Link removed (%s). Scheduling signal data purge.", link)
self.purge_link(link)
link.enabled_changed.disconnect(self.link_enabled_changed)
def link_enabled_changed(self, enabled):
if enabled:
link = self.sender()
log.info("Link %s enabled. Scheduling signal data update.", link)
self._schedule(self.signals_on_link(link))
def signals_on_link(self, link):
"""
Return _Signal instances representing the current values
present on the link.
"""
items = self.link_contents(link)
signals = []
for key, value in list(items.items()):
signals.append(_Signal(link, value, key))
return signals
def link_contents(self, link):
"""
Return the contents on link.
"""
node, channel = link.source_node, link.source_channel
if node in self._node_outputs:
return self._node_outputs[node][channel]
else:
# if the the node was already removed it's tracked outputs in
# _node_outputs are cleared, however the final 'None' signal
# deliveries for the link are left in the _input_queue.
pending = [sig for sig in self._input_queue if sig.link is link]
return {sig.id: sig.value for sig in pending}
def send(self, node, channel, value, id):
"""
"""
log.debug("%r sending %r (id: %r) on channel %r", node.title, type(value), id, channel.name)
scheme = self.scheme()
self._node_outputs[node][channel][id] = value
links = scheme.find_links(source_node=node, source_channel=channel)
links = list(filter(is_enabled, links))
signals = []
for link in links:
signals.append(_Signal(link, value, id))
self._schedule(signals)
def purge_link(self, link):
"""
Purge the link (send None for all ids currently present)
"""
contents = self.link_contents(link)
ids = list(contents.keys())
signals = [_Signal(link, None, id) for id in ids]
self._schedule(signals)
def _schedule(self, signals):
"""
Schedule a list of :class:`_Signal` for delivery.
"""
self._input_queue.extend(signals)
for link in {sig.link for sig in signals}:
# update the SchemeLink's runtime state flags
contents = self.link_contents(link)
if any(value is not None for value in contents.values()):
state = SchemeLink.Active
else:
state = SchemeLink.Empty
link.set_runtime_state(state | SchemeLink.Pending)
if signals:
self.updatesPending.emit()
self._update()
def _update_link(self, link):
"""
Schedule update of a single link.
"""
signals = self.signals_on_link(link)
self._schedule(signals)
def process_queued(self, max_nodes=None):
"""
Process queued signals.
Take one node node from the pending input queue and deliver
all scheduled signals.
"""
if max_nodes is not None or max_nodes != 1:
warnings.warn(
"`max_nodes` is deprecated and unused (will always equal 1)", DeprecationWarning, stacklevel=2
)
if self.__runtime_state == SignalManager.Processing:
raise RuntimeError("Cannot re-enter 'process_queued'")
if not self._can_process():
raise RuntimeError("Can't process in state %i" % self.__state)
log.info("SignalManager: Processing queued signals")
node_update_front = self.node_update_front()
log.debug("SignalManager: Nodes eligible for update %s", [node.title for node in node_update_front])
if node_update_front:
node = node_update_front[0]
self._set_runtime_state(SignalManager.Processing)
try:
self.process_node(node)
finally:
self._set_runtime_state(SignalManager.Waiting)
def process_node(self, node):
"""
Process pending input signals for `node`.
"""
signals_in = self.pending_input_signals(node)
self.remove_pending_signals(node)
signals_in = self.compress_signals(signals_in)
log.debug("Processing %r, sending %i signals.", node.title, len(signals_in))
# Clear the link's pending flag.
for link in {sig.link for sig in signals_in}:
link.set_runtime_state(link.runtime_state() & ~SchemeLink.Pending)
assert {sig.link for sig in self._input_queue}.intersection({sig.link for sig in signals_in}) == set([])
self.processingStarted.emit()
self.processingStarted[SchemeNode].emit(node)
try:
self.send_to_node(node, signals_in)
finally:
self.processingFinished.emit()
self.processingFinished[SchemeNode].emit(node)
def compress_signals(self, signals):
"""
Compress a list of :class:`_Signal` instances to be delivered.
The base implementation returns the list unmodified.
"""
return signals
def send_to_node(self, node, signals):
"""
Abstract. Reimplement in subclass.
Send/notify the :class:`SchemeNode` instance (or whatever
object/instance it is a representation of) that it has new inputs
as represented by the signals list (list of :class:`_Signal`).
"""
raise NotImplementedError
def is_pending(self, node):
"""
Is `node` (class:`SchemeNode`) scheduled for processing (i.e.
it has incoming pending signals).
"""
return node in [signal.link.sink_node for signal in self._input_queue]
def pending_nodes(self):
"""
Return a list of pending nodes.
The nodes are returned in the order they were enqueued for
signal delivery.
Returns
-------
nodes : List[SchemeNode]
"""
return list(unique(sig.link.sink_node for sig in self._input_queue))
def pending_input_signals(self, node):
"""
Return a list of pending input signals for node.
"""
return [signal for signal in self._input_queue if node is signal.link.sink_node]
def remove_pending_signals(self, node):
"""
Remove pending signals for `node`.
"""
for signal in self.pending_input_signals(node):
try:
self._input_queue.remove(signal)
except ValueError:
pass
def blocking_nodes(self):
"""
Return a list of nodes in a blocking state.
"""
scheme = self.scheme()
return [node for node in scheme.nodes if self.is_blocking(node)]
def is_blocking(self, node):
return False
def node_update_front(self):
"""
Return a list of nodes on the update front, i.e. nodes scheduled for
an update that have no ancestor which is either itself scheduled
for update or is in a blocking state)
.. note::
The node's ancestors are only computed over enabled links.
"""
scheme = self.scheme()
blocking_nodes = set(self.blocking_nodes())
dependents = partial(dependent_nodes, scheme)
blocked_nodes = reduce(set.union, map(dependents, blocking_nodes), set(blocking_nodes))
pending = self.pending_nodes()
pending_downstream = reduce(set.union, map(dependents, pending), set())
log.debug("Pending nodes: %s", pending)
log.debug("Blocking nodes: %s", blocking_nodes)
noneligible = pending_downstream | blocked_nodes
return [node for node in pending if node not in noneligible]
@Slot()
def __process_next(self):
if not self.__state == SignalManager.Running:
log.debug("Received 'UpdateRequest' while not in 'Running' state")
return
if self.__runtime_state == SignalManager.Processing:
# This happens if someone calls QCoreApplication.processEvents
# from the signal handlers.
# A `__process_next` must be rescheduled when exiting
# process_queued.
log.warning(
"Received 'UpdateRequest' while in 'process_queued'. "
"An update will be re-scheduled when exiting the "
"current update."
)
self.__reschedule = True
return
log.info("'UpdateRequest' event, queued signals: %i", len(self._input_queue))
if self._input_queue:
self.process_queued()
if self.__reschedule and self.__state == SignalManager.Running:
self.__reschedule = False
log.debug("Rescheduling signal update")
self.__update_timer.start()
if self.node_update_front():
log.debug("More nodes are eligible for an update. " "Scheduling another update.")
self._update()
def _update(self):
"""
Schedule processing at a later time.
"""
if self.__state == SignalManager.Running and not self.__update_timer.isActive():
self.__update_timer.start()
class OWTimeSlice(widget.OWWidget):
name = 'Time Slice'
description = 'Select a slice of measurements on a time interval.'
icon = 'icons/TimeSlice.svg'
priority = 550
inputs = [
('Data', Table, 'set_data'),
]
outputs = [('Subset', Table)]
want_main_area = False
class Error(widget.OWWidget.Error):
no_time_variable = widget.Msg('Data contains no time variable')
MAX_SLIDER_VALUE = 500
DATE_FORMATS = ('yyyy-MM-dd', 'HH:mm:ss.zzz')
OVERLAP_AMOUNTS = OrderedDict(
(('all but one (= shift by one slider value)',
0), ('6/7 of interval', 6 / 7), ('3/4 of interval', 3 / 4),
('1/2 of interval', 1 / 2), ('1/3 of interval',
1 / 3), ('1/5 of interval', 1 / 5)))
loop_playback = settings.Setting(True)
steps_overlap = settings.Setting(True)
overlap_amount = settings.Setting(next(iter(OVERLAP_AMOUNTS)))
playback_interval = settings.Setting(1000)
slider_values = settings.Setting((0, .2 * MAX_SLIDER_VALUE))
def __init__(self):
super().__init__()
self._delta = 0
self.play_timer = QTimer(self,
interval=self.playback_interval,
timeout=self.play_single_step)
slider = self.slider = Slider(
Qt.Horizontal,
self,
minimum=0,
maximum=self.MAX_SLIDER_VALUE,
tracking=False,
valuesChanged=self.valuesChanged,
minimumValue=self.slider_values[0],
maximumValue=self.slider_values[1],
)
slider.setShowText(False)
box = gui.vBox(self.controlArea, 'Time Slice')
box.layout().addWidget(slider)
hbox = gui.hBox(box)
def _dateTimeChanged(editted):
def handler():
minTime = self.date_from.dateTime().toMSecsSinceEpoch() / 1000
maxTime = self.date_to.dateTime().toMSecsSinceEpoch() / 1000
if minTime > maxTime:
minTime = maxTime = minTime if editted == self.date_from else maxTime
other = self.date_to if editted == self.date_from else self.date_from
with blockSignals(other):
other.setDateTime(editted.dateTime())
with blockSignals(self.slider):
self.slider.setValues(self.slider.unscale(minTime),
self.slider.unscale(maxTime))
self.send_selection(minTime, maxTime)
return handler
kwargs = dict(calendarPopup=True,
displayFormat=' '.join(self.DATE_FORMATS),
timeSpec=Qt.UTC)
date_from = self.date_from = QDateTimeEdit(self, **kwargs)
date_to = self.date_to = QDateTimeEdit(self, **kwargs)
date_from.dateTimeChanged.connect(_dateTimeChanged(date_from))
date_to.dateTimeChanged.connect(_dateTimeChanged(date_to))
hbox.layout().addStretch(100)
hbox.layout().addWidget(date_from)
hbox.layout().addWidget(QLabel(' – '))
hbox.layout().addWidget(date_to)
hbox.layout().addStretch(100)
vbox = gui.vBox(self.controlArea, 'Step / Play Through')
gui.checkBox(vbox, self, 'loop_playback', label='Loop playback')
hbox = gui.hBox(vbox)
gui.checkBox(hbox,
self,
'steps_overlap',
label='Stepping overlaps by:',
toolTip='If enabled, the active interval moves forward '
'(backward) by half of the interval at each step.')
gui.comboBox(hbox,
self,
'overlap_amount',
items=tuple(self.OVERLAP_AMOUNTS.keys()),
sendSelectedValue=True)
gui.spin(vbox,
self,
'playback_interval',
label='Playback delay (msec):',
minv=100,
maxv=30000,
step=200,
callback=lambda: self.play_timer.setInterval(
self.playback_interval))
hbox = gui.hBox(vbox)
self.step_backward = gui.button(
hbox,
self,
'⏮',
callback=lambda: self.play_single_step(backward=True),
autoDefault=False)
self.play_button = gui.button(hbox,
self,
'▶',
callback=self.playthrough,
toggleButton=True,
default=True)
self.step_forward = gui.button(hbox,
self,
'⏭',
callback=self.play_single_step,
autoDefault=False)
gui.rubber(self.controlArea)
def valuesChanged(self, minValue, maxValue):
self.slider_values = (minValue, maxValue)
self._delta = max(1, (maxValue - minValue))
minTime = self.slider.scale(minValue)
maxTime = self.slider.scale(maxValue)
from_dt = QDateTime.fromMSecsSinceEpoch(minTime * 1000).toUTC()
to_dt = QDateTime.fromMSecsSinceEpoch(maxTime * 1000).toUTC()
with blockSignals(self.date_from, self.date_to):
self.date_from.setDateTime(from_dt)
self.date_to.setDateTime(to_dt)
self.send_selection(minTime, maxTime)
def send_selection(self, minTime, maxTime):
try:
time_values = self.data.time_values
except AttributeError:
return
indices = (minTime <= time_values) & (time_values <= maxTime)
self.send('Subset', self.data[indices] if indices.any() else None)
def playthrough(self):
playing = self.play_button.isChecked()
for widget in (self.slider, self.step_forward, self.step_backward):
widget.setDisabled(playing)
if playing:
self.play_timer.start()
self.play_button.setText('▮▮')
else:
self.play_timer.stop()
self.play_button.setText('▶')
def play_single_step(self, backward=False):
op = operator.sub if backward else operator.add
minValue, maxValue = self.slider.values()
orig_delta = delta = self._delta
if self.steps_overlap:
overlap_amount = self.OVERLAP_AMOUNTS[self.overlap_amount]
if overlap_amount:
delta = max(1, int(round(delta * (1 - overlap_amount))))
else:
delta = 1 # single slider step (== 1/self.MAX_SLIDER_VALUE)
if maxValue == self.slider.maximum() and not backward:
minValue = self.slider.minimum()
maxValue = minValue + orig_delta
if not self.loop_playback:
self.play_button.click()
assert not self.play_timer.isActive()
assert not self.play_button.isChecked()
elif minValue == self.slider.minimum() and backward:
maxValue = self.slider.maximum()
minValue = maxValue - orig_delta
else:
minValue = op(minValue, delta)
maxValue = op(maxValue, delta)
# Blocking signals because we want this to be synchronous to avoid
# re-setting self._delta
with blockSignals(self.slider):
self.slider.setValues(minValue, maxValue)
self.valuesChanged(self.slider.minimumValue(),
self.slider.maximumValue())
self._delta = orig_delta # Override valuesChanged handler
def set_data(self, data):
slider = self.slider
self.data = data = None if data is None else Timeseries.from_data_table(
data)
def disabled():
slider.setFormatter(str)
slider.setHistogram(None)
slider.setScale(0, 0)
slider.setValues(0, 0)
slider.setDisabled(True)
self.send('Subset', None)
if data is None:
disabled()
return
if not isinstance(data.time_variable, TimeVariable):
self.Error.no_time_variable()
disabled()
return
self.Error.clear()
var = data.time_variable
time_values = data.time_values
slider.setDisabled(False)
slider.setHistogram(time_values)
slider.setFormatter(var.repr_val)
slider.setScale(time_values.min(), time_values.max())
self.valuesChanged(slider.minimumValue(), slider.maximumValue())
# Update datetime edit fields
min_dt = QDateTime.fromMSecsSinceEpoch(time_values[0] * 1000).toUTC()
max_dt = QDateTime.fromMSecsSinceEpoch(time_values[-1] * 1000).toUTC()
self.date_from.setDateTimeRange(min_dt, max_dt)
self.date_to.setDateTimeRange(min_dt, max_dt)
date_format = ' '.join(
(self.DATE_FORMATS[0] if var.have_date else '',
self.DATE_FORMATS[1] if var.have_time else '')).strip()
self.date_from.setDisplayFormat(date_format)
self.date_to.setDisplayFormat(date_format)
class OWTimeSlice(widget.OWWidget):
name = 'Time Slice'
description = 'Select a slice of measurements on a time interval.'
icon = 'icons/TimeSlice.svg'
priority = 550
class Inputs:
data = Input("Data", Table)
class Outputs:
subset = Output("Subset", Table)
want_main_area = False
class Error(widget.OWWidget.Error):
no_time_variable = widget.Msg('Data contains no time variable')
MAX_SLIDER_VALUE = 500
DATE_FORMATS = ('yyyy-MM-dd', 'HH:mm:ss.zzz')
OVERLAP_AMOUNTS = OrderedDict((
('all but one (= shift by one slider value)', 0),
('6/7 of interval', 6/7),
('3/4 of interval', 3/4),
('1/2 of interval', 1/2),
('1/3 of interval', 1/3),
('1/5 of interval', 1/5)))
loop_playback = settings.Setting(True)
steps_overlap = settings.Setting(True)
overlap_amount = settings.Setting(next(iter(OVERLAP_AMOUNTS)))
playback_interval = settings.Setting(1000)
slider_values = settings.Setting((0, .2 * MAX_SLIDER_VALUE))
def __init__(self):
super().__init__()
self._delta = 0
self.play_timer = QTimer(self,
interval=self.playback_interval,
timeout=self.play_single_step)
slider = self.slider = Slider(Qt.Horizontal, self,
minimum=0, maximum=self.MAX_SLIDER_VALUE,
tracking=False,
valuesChanged=self.valuesChanged,
minimumValue=self.slider_values[0],
maximumValue=self.slider_values[1],)
slider.setShowText(False)
box = gui.vBox(self.controlArea, 'Time Slice')
box.layout().addWidget(slider)
hbox = gui.hBox(box)
def _dateTimeChanged(editted):
def handler():
minTime = self.date_from.dateTime().toMSecsSinceEpoch() / 1000
maxTime = self.date_to.dateTime().toMSecsSinceEpoch() / 1000
if minTime > maxTime:
minTime = maxTime = minTime if editted == self.date_from else maxTime
other = self.date_to if editted == self.date_from else self.date_from
with blockSignals(other):
other.setDateTime(editted.dateTime())
with blockSignals(self.slider):
self.slider.setValues(self.slider.unscale(minTime),
self.slider.unscale(maxTime))
self.send_selection(minTime, maxTime)
return handler
kwargs = dict(calendarPopup=True,
displayFormat=' '.join(self.DATE_FORMATS),
timeSpec=Qt.UTC)
date_from = self.date_from = QDateTimeEdit(self, **kwargs)
date_to = self.date_to = QDateTimeEdit(self, **kwargs)
date_from.dateTimeChanged.connect(_dateTimeChanged(date_from))
date_to.dateTimeChanged.connect(_dateTimeChanged(date_to))
hbox.layout().addStretch(100)
hbox.layout().addWidget(date_from)
hbox.layout().addWidget(QLabel(' – '))
hbox.layout().addWidget(date_to)
hbox.layout().addStretch(100)
vbox = gui.vBox(self.controlArea, 'Step / Play Through')
gui.checkBox(vbox, self, 'loop_playback',
label='Loop playback')
hbox = gui.hBox(vbox)
gui.checkBox(hbox, self, 'steps_overlap',
label='Stepping overlaps by:',
toolTip='If enabled, the active interval moves forward '
'(backward) by half of the interval at each step.')
gui.comboBox(hbox, self, 'overlap_amount',
items=tuple(self.OVERLAP_AMOUNTS.keys()),
sendSelectedValue=True)
gui.spin(vbox, self, 'playback_interval',
label='Playback delay (msec):',
minv=100, maxv=30000, step=200,
callback=lambda: self.play_timer.setInterval(self.playback_interval))
hbox = gui.hBox(vbox)
self.step_backward = gui.button(hbox, self, '⏮',
callback=lambda: self.play_single_step(backward=True),
autoDefault=False)
self.play_button = gui.button(hbox, self, '▶',
callback=self.playthrough,
toggleButton=True, default=True)
self.step_forward = gui.button(hbox, self, '⏭',
callback=self.play_single_step,
autoDefault=False)
gui.rubber(self.controlArea)
self._set_disabled(True)
def valuesChanged(self, minValue, maxValue):
self.slider_values = (minValue, maxValue)
self._delta = max(1, (maxValue - minValue))
minTime = self.slider.scale(minValue)
maxTime = self.slider.scale(maxValue)
from_dt = QDateTime.fromMSecsSinceEpoch(minTime * 1000).toUTC()
to_dt = QDateTime.fromMSecsSinceEpoch(maxTime * 1000).toUTC()
with blockSignals(self.date_from,
self.date_to):
self.date_from.setDateTime(from_dt)
self.date_to.setDateTime(to_dt)
self.send_selection(minTime, maxTime)
def send_selection(self, minTime, maxTime):
try:
time_values = self.data.time_values
except AttributeError:
return
indices = (minTime <= time_values) & (time_values <= maxTime)
self.Outputs.subset.send(self.data[indices] if indices.any() else None)
def playthrough(self):
playing = self.play_button.isChecked()
for widget in (self.slider,
self.step_forward,
self.step_backward):
widget.setDisabled(playing)
if playing:
self.play_timer.start()
self.play_button.setText('▮▮')
else:
self.play_timer.stop()
self.play_button.setText('▶')
def play_single_step(self, backward=False):
op = operator.sub if backward else operator.add
minValue, maxValue = self.slider.values()
orig_delta = delta = self._delta
if self.steps_overlap:
overlap_amount = self.OVERLAP_AMOUNTS[self.overlap_amount]
if overlap_amount:
delta = max(1, int(round(delta * (1 - overlap_amount))))
else:
delta = 1 # single slider step (== 1/self.MAX_SLIDER_VALUE)
if maxValue == self.slider.maximum() and not backward:
minValue = self.slider.minimum()
maxValue = minValue + orig_delta
if not self.loop_playback:
self.play_button.click()
assert not self.play_timer.isActive()
assert not self.play_button.isChecked()
elif minValue == self.slider.minimum() and backward:
maxValue = self.slider.maximum()
minValue = maxValue - orig_delta
else:
minValue = op(minValue, delta)
maxValue = op(maxValue, delta)
# Blocking signals because we want this to be synchronous to avoid
# re-setting self._delta
with blockSignals(self.slider):
self.slider.setValues(minValue, maxValue)
self.valuesChanged(self.slider.minimumValue(), self.slider.maximumValue())
self._delta = orig_delta # Override valuesChanged handler
def _set_disabled(self, is_disabled):
for func in [self.date_from, self.date_to, self.step_backward, self.play_button,
self.step_forward, self.controls.loop_playback,
self.controls.steps_overlap, self.controls.overlap_amount,
self.controls.playback_interval, self.slider]:
func.setDisabled(is_disabled)
@Inputs.data
def set_data(self, data):
slider = self.slider
self.data = data = None if data is None else Timeseries.from_data_table(data)
def disabled():
slider.setFormatter(str)
slider.setHistogram(None)
slider.setScale(0, 0)
slider.setValues(0, 0)
self._set_disabled(True)
self.Outputs.subset.send(None)
if data is None:
disabled()
return
if not isinstance(data.time_variable, TimeVariable):
self.Error.no_time_variable()
disabled()
return
self.Error.clear()
var = data.time_variable
time_values = data.time_values
self._set_disabled(False)
slider.setHistogram(time_values)
slider.setFormatter(var.repr_val)
slider.setScale(time_values.min(), time_values.max())
self.valuesChanged(slider.minimumValue(), slider.maximumValue())
# Update datetime edit fields
min_dt = QDateTime.fromMSecsSinceEpoch(time_values[0] * 1000).toUTC()
max_dt = QDateTime.fromMSecsSinceEpoch(time_values[-1] * 1000).toUTC()
self.date_from.setDateTimeRange(min_dt, max_dt)
self.date_to.setDateTimeRange(min_dt, max_dt)
date_format = ' '.join((self.DATE_FORMATS[0] if var.have_date else '',
self.DATE_FORMATS[1] if var.have_time else '')).strip()
self.date_from.setDisplayFormat(date_format)
self.date_to.setDisplayFormat(date_format)
class ComboBox(QComboBox):
"""
A QComboBox subclass extended to support bounded contents width hint.
Prefer to use this class in place of plain QComboBox when the used
model will possibly contain many items.
"""
def __init__(self, parent=None, **kwargs):
self.__maximumContentsLength = MAXIMUM_CONTENTS_LENGTH
super().__init__(parent, **kwargs)
self.__in_mousePressEvent = False
# Yet Another Mouse Release Ignore Timer
self.__yamrit = QTimer(self, singleShot=True)
view = self.view()
# optimization for displaying large models
if isinstance(view, QListView):
view.setUniformItemSizes(True)
view.viewport().installEventFilter(self)
def setMaximumContentsLength(self, length): # type: (int) -> None
"""
Set the maximum contents length hint.
The hint specifies the upper bound on the `sizeHint` and
`minimumSizeHint` width specified in character length.
Set to 0 or negative value to disable.
Note
----
This property does not affect the widget's `maximumSize`.
The widget can still grow depending on its `sizePolicy`.
Parameters
----------
length : int
Maximum contents length hint.
"""
if self.__maximumContentsLength != length:
self.__maximumContentsLength = length
self.updateGeometry()
def maximumContentsLength(self): # type: () -> int
"""
Return the maximum contents length hint.
"""
return self.__maximumContentsLength
def _get_size_hint(self):
sh = super().sizeHint()
if self.__maximumContentsLength > 0:
width = (
self.fontMetrics().width("X") * self.__maximumContentsLength
+ self.iconSize().width() + 4
)
sh = sh.boundedTo(QSize(width, sh.height()))
return sh
def sizeHint(self): # type: () -> QSize
# reimplemented
return self._get_size_hint()
def minimumSizeHint(self): # type: () -> QSize
# reimplemented
return self._get_size_hint()
# workaround for QTBUG-67583
def mousePressEvent(self, event): # type: (QMouseEvent) -> None
# reimplemented
self.__in_mousePressEvent = True
super().mousePressEvent(event)
self.__in_mousePressEvent = False
def showPopup(self): # type: () -> None
# reimplemented
super().showPopup()
if self.__in_mousePressEvent:
self.__yamrit.start(QApplication.doubleClickInterval())
def eventFilter(self, obj, event):
# type: (QObject, QEvent) -> bool
if event.type() == QEvent.MouseButtonRelease \
and event.button() == Qt.LeftButton \
and obj is self.view().viewport() \
and self.__yamrit.isActive():
return True
else:
return super().eventFilter(obj, event)
class OWTimeSlice(widget.OWWidget):
name = 'Time Slice'
description = 'Select a slice of measurements on a time interval.'
icon = 'icons/TimeSlice.svg'
priority = 550
class Inputs:
data = Input("Data", Table)
class Outputs:
subset = Output("Subset", Table)
settings_version = 2
want_main_area = False
class Error(widget.OWWidget.Error):
no_time_variable = widget.Msg('Data contains no time variable')
no_time_delta = widget.Msg('Data contains only one time point')
MAX_SLIDER_VALUE = 500
DATE_FORMATS = ('yyyy', '-MM', '-dd', ' HH:mm:ss.zzz')
# only appropriate overlap amounts are shown, but these are all the options
DELAY_VALUES = (0.1, 0.2, 0.5, 1, 2, 5, 10, 15, 30)
STEP_SIZES = OrderedDict(
(('1 second', 1), ('5 seconds', 5), ('10 seconds', 10),
('15 seconds', 15), ('30 seconds', 30), ('1 minute', 60),
('5 minutes', 300), ('10 minutes', 600), ('15 minutes', 900),
('30 minutes', 1800), ('1 hour', 3600), ('2 hours', 7200),
('3 hours', 10800), ('6 hours', 21600), ('12 hours', 43200),
('1 day', 86400), ('1 week', 604800), ('2 weeks', 1209600),
('1 month', (1, 'month')), ('2 months', (2, 'month')), ('3 months',
(3, 'month')),
('6 months', (6, 'month')), ('1 year', (1, 'year')), ('2 years',
(2, 'year')),
('5 years', (5, 'year')), ('10 years', (10, 'year')), ('25 years',
(25, 'year')),
('50 years', (50, 'year')), ('100 years', (100, 'year'))))
loop_playback = settings.Setting(True)
custom_step_size = settings.Setting(False)
step_size = settings.Setting(next(iter(STEP_SIZES)))
playback_interval = settings.Setting(1)
slider_values = settings.Setting((0, .2 * MAX_SLIDER_VALUE))
icons_font = None
def __init__(self):
super().__init__()
self._delta = 0
self.play_timer = QTimer(self,
interval=1000 * self.playback_interval,
timeout=self.play_single_step)
slider = self.slider = Slider(Qt.Horizontal,
self,
minimum=0,
maximum=self.MAX_SLIDER_VALUE,
tracking=True,
playbackInterval=1000 *
self.playback_interval,
valuesChanged=self.sliderValuesChanged,
minimumValue=self.slider_values[0],
maximumValue=self.slider_values[1])
slider.setShowText(False)
selectBox = gui.vBox(self.controlArea, 'Select a Time Range')
selectBox.layout().addWidget(slider)
dtBox = gui.hBox(selectBox)
kwargs = dict(calendarPopup=True,
displayFormat=' '.join(self.DATE_FORMATS),
timeSpec=Qt.UTC)
date_from = self.date_from = QDateTimeEdit(self, **kwargs)
date_to = self.date_to = QDateTimeEdit(self, **kwargs)
def datetime_edited(dt_edit):
minTime = self.date_from.dateTime().toMSecsSinceEpoch() / 1000
maxTime = self.date_to.dateTime().toMSecsSinceEpoch() / 1000
if minTime > maxTime:
minTime = maxTime = minTime if dt_edit == self.date_from else maxTime
other = self.date_to if dt_edit == self.date_from else self.date_from
with blockSignals(other):
other.setDateTime(dt_edit.dateTime())
self.dteditValuesChanged(minTime, maxTime)
date_from.dateTimeChanged.connect(lambda: datetime_edited(date_from))
date_to.dateTimeChanged.connect(lambda: datetime_edited(date_to))
# hotfix, does not repaint on click of arrow
date_from.calendarWidget().currentPageChanged.connect(
lambda: date_from.calendarWidget().repaint())
date_to.calendarWidget().currentPageChanged.connect(
lambda: date_to.calendarWidget().repaint())
dtBox.layout().addStretch(100)
dtBox.layout().addWidget(date_from)
dtBox.layout().addWidget(QLabel(' – '))
dtBox.layout().addWidget(date_to)
dtBox.layout().addStretch(100)
hCenterBox = gui.hBox(self.controlArea)
gui.rubber(hCenterBox)
vControlsBox = gui.vBox(hCenterBox)
stepThroughBox = gui.vBox(vControlsBox, 'Step/Play Through')
gui.rubber(stepThroughBox)
gui.checkBox(stepThroughBox,
self,
'loop_playback',
label='Loop playback')
customStepBox = gui.hBox(stepThroughBox)
gui.checkBox(
customStepBox,
self,
'custom_step_size',
label='Custom step size: ',
toolTip='If not chosen, the active interval moves forward '
'(backward), stepping in increments of its own size.')
self.stepsize_combobox = gui.comboBox(customStepBox,
self,
'step_size',
items=tuple(
self.STEP_SIZES.keys()),
sendSelectedValue=True)
playBox = gui.hBox(stepThroughBox)
gui.rubber(playBox)
gui.rubber(stepThroughBox)
if self.icons_font is None:
self.icons_font = load_icons_font()
self.step_backward = gui.button(
playBox,
self,
'⏪',
callback=lambda: self.play_single_step(backward=True),
autoDefault=False)
self.step_backward.setFont(self.icons_font)
self.play_button = gui.button(playBox,
self,
'▶️',
callback=self.playthrough,
toggleButton=True,
default=True)
self.play_button.setFont(self.icons_font)
self.step_forward = gui.button(playBox,
self,
'⏩',
callback=self.play_single_step,
autoDefault=False)
self.step_forward.setFont(self.icons_font)
gui.rubber(playBox)
intervalBox = gui.vBox(vControlsBox, 'Playback/Tracking interval')
intervalBox.setToolTip(
'In milliseconds, set the delay for playback and '
'for sending data upon manually moving the interval.')
def set_intervals():
self.play_timer.setInterval(1000 * self.playback_interval)
self.slider.tracking_timer.setInterval(1000 *
self.playback_interval)
gui.valueSlider(intervalBox,
self,
'playback_interval',
label='Delay:',
labelFormat='%.2g sec',
values=self.DELAY_VALUES,
callback=set_intervals)
gui.rubber(hCenterBox)
gui.rubber(self.controlArea)
self._set_disabled(True)
def sliderValuesChanged(self, minValue, maxValue):
self._delta = max(1, (maxValue - minValue))
minTime = self.slider.scale(minValue)
maxTime = self.slider.scale(maxValue)
from_dt = QDateTime.fromMSecsSinceEpoch(minTime * 1000).toUTC()
to_dt = QDateTime.fromMSecsSinceEpoch(maxTime * 1000).toUTC()
if self.date_from.dateTime() != from_dt:
with blockSignals(self.date_from):
self.date_from.setDateTime(from_dt)
if self.date_from.dateTime() != to_dt:
with blockSignals(self.date_to):
self.date_to.setDateTime(to_dt)
self.send_selection(minTime, maxTime)
def dteditValuesChanged(self, minTime, maxTime):
minValue = self.slider.unscale(minTime)
maxValue = self.slider.unscale(maxTime)
if minValue == maxValue:
# maxValue's range is minValue's range shifted by one
maxValue += 1
maxTime = self.slider.scale(maxValue)
to_dt = QDateTime.fromMSecsSinceEpoch(maxTime * 1000).toUTC()
with blockSignals(self.date_to):
self.date_to.setDateTime(to_dt)
self._delta = max(1, (maxValue - minValue))
if self.slider_values != (minValue, maxValue):
self.slider_values = (minValue, maxValue)
with blockSignals(self.slider):
self.slider.setValues(minValue, maxValue)
self.send_selection(minTime, maxTime)
def send_selection(self, minTime, maxTime):
try:
time_values = self.data.time_values
except AttributeError:
return
indices = (minTime <= time_values) & (time_values < maxTime)
self.Outputs.subset.send(self.data[indices] if indices.any() else None)
def playthrough(self):
playing = self.play_button.isChecked()
for widget in (self.slider, self.step_forward, self.step_backward):
widget.setDisabled(playing)
for widget in (self.date_from, self.date_to):
widget.setReadOnly(playing)
if playing:
self.play_timer.start()
self.play_button.setText('⏸')
else:
self.play_timer.stop()
self.play_button.setText('▶️')
# hotfix
self.repaint()
def play_single_step(self, backward=False):
minValue, maxValue = self.slider.values()
orig_delta = delta = self._delta
def new_value(value):
if self.custom_step_size:
step_amount = self.STEP_SIZES[self.step_size]
time = datetime.datetime.fromtimestamp(
self.slider.scale(value), tz=datetime.timezone.utc)
newTime = add_time(time, step_amount, -1 if backward else 1)
return self.slider.unscale(newTime.timestamp())
return value + (-delta if backward else delta)
if maxValue == self.slider.maximum() and not backward:
minValue = self.slider.minimum()
maxValue = self.slider.minimum() + delta
if not self.loop_playback:
self.play_button.click()
assert not self.play_timer.isActive()
assert not self.play_button.isChecked()
elif minValue == self.slider.minimum() and backward:
maxValue = self.slider.maximum()
minValue = min(self.slider.maximum(), new_value(maxValue))
else:
minValue = min(new_value(minValue), self.slider.maximum())
maxValue = min(new_value(maxValue), self.slider.maximum())
# Blocking signals because we want this to be synchronous to avoid
# re-setting self._delta
with blockSignals(self.slider):
self.slider.setValues(minValue, maxValue)
self.sliderValuesChanged(self.slider.minimumValue(),
self.slider.maximumValue())
self._delta = orig_delta # Override valuesChanged handler
# hotfix
self.slider.repaint()
def _set_disabled(self, is_disabled):
if is_disabled and self.play_timer.isActive():
self.play_button.click()
assert not self.play_timer.isActive()
assert not self.play_button.isChecked()
for func in [
self.date_from, self.date_to, self.step_backward,
self.play_button, self.step_forward,
self.controls.loop_playback, self.controls.step_size,
self.controls.playback_interval, self.slider
]:
func.setDisabled(is_disabled)
@Inputs.data
def set_data(self, data):
slider = self.slider
self.data = data = None if data is None else Timeseries.from_data_table(
data)
def disabled():
slider.setFormatter(str)
slider.setHistogram(None)
slider.setScale(0, 0, None)
slider.setValues(0, 0)
self._set_disabled(True)
self.Outputs.subset.send(None)
if data is None:
disabled()
return
if not isinstance(data.time_variable, TimeVariable):
self.Error.no_time_variable()
disabled()
return
if not data.time_delta.deltas:
self.Error.no_time_delta()
disabled()
return
self.Error.clear()
var = data.time_variable
time_values = data.time_values
min_dt = datetime.datetime.fromtimestamp(round(time_values.min()),
tz=datetime.timezone.utc)
max_dt = datetime.datetime.fromtimestamp(round(time_values.max()),
tz=datetime.timezone.utc)
# Depending on time delta:
# - set slider maximum (granularity)
# - set range for end dt (+ 1 timedelta)
# - set date format
# - set time overlap options
delta = data.time_delta.gcd
range = max_dt - min_dt
if isinstance(delta, Number):
maximum = round(range.total_seconds() / delta)
timedelta = datetime.timedelta(milliseconds=delta * 1000)
min_dt2 = min_dt + timedelta
max_dt2 = max_dt + timedelta
if delta >= 86400: # more than a day
date_format = ''.join(self.DATE_FORMATS[0:3])
else:
date_format = ''.join(self.DATE_FORMATS)
for k, n in [(k, n) for k, n in self.STEP_SIZES.items()
if isinstance(n, Number)]:
if delta <= n:
min_overlap = k
break
else:
min_overlap = '1 day'
else: # isinstance(delta, tuple)
if delta[1] == 'month':
months = (max_dt.year - min_dt.year) * 12 + \
(max_dt.month - min_dt.month)
maximum = months / delta[0]
if min_dt.month < 12 - delta[0]:
min_dt2 = min_dt.replace(month=min_dt.month + delta[0])
else:
min_dt2 = min_dt.replace(year=min_dt.year + 1,
month=12 - min_dt.month +
delta[0])
if max_dt.month < 12 - delta[0]:
max_dt2 = max_dt.replace(month=max_dt.month + delta[0])
else:
max_dt2 = max_dt.replace(year=max_dt.year + 1,
month=12 - min_dt.month +
delta[0])
date_format = ''.join(self.DATE_FORMATS[0:2])
for k, (i, u) in [(k, v) for k, v in self.STEP_SIZES.items()
if isinstance(v, tuple) and v[1] == 'month']:
if delta[0] <= i:
min_overlap = k
break
else:
min_overlap = '1 year'
else: # elif delta[1] == 'year':
years = max_dt.year - min_dt.year
maximum = years / delta[0]
min_dt2 = min_dt.replace(year=min_dt.year + delta[0], )
max_dt2 = max_dt.replace(year=max_dt.year + delta[0], )
date_format = self.DATE_FORMATS[0]
for k, (i, u) in [(k, v) for k, v in self.STEP_SIZES.items()
if isinstance(v, tuple) and v[1] == 'year']:
if delta[0] <= i:
min_overlap = k
break
else:
raise Exception('Timedelta larger than 100 years')
# find max sensible time overlap
upper_overlap_limit = range / 2
for k, overlap in self.STEP_SIZES.items():
if isinstance(overlap, Number):
if upper_overlap_limit.total_seconds() <= overlap:
max_overlap = k
break
else:
i, u = overlap
if u == 'month':
month_diff = (max_dt.year - min_dt.year) * 12 \
+ max(0, max_dt.month - min_dt.month)
if month_diff / 2 <= i:
max_overlap = k
break
else: # if u == 'year':
year_diff = max_dt.year - min_dt.year
if year_diff / 2 <= i:
max_overlap = k
break
else:
# last item in step sizes
*_, max_overlap = self.STEP_SIZES.keys()
self.stepsize_combobox.clear()
dict_iter = iter(self.STEP_SIZES.keys())
next_item = next(dict_iter)
while next_item != min_overlap:
next_item = next(dict_iter)
self.stepsize_combobox.addItem(next_item)
self.step_size = next_item
while next_item != max_overlap:
next_item = next(dict_iter)
self.stepsize_combobox.addItem(next_item)
slider.setMinimum(0)
slider.setMaximum(maximum + 1)
self._set_disabled(False)
slider.setHistogram(time_values)
slider.setFormatter(var.repr_val)
slider.setScale(time_values.min(), time_values.max(),
data.time_delta.gcd)
self.sliderValuesChanged(slider.minimumValue(), slider.maximumValue())
def utc_dt(dt):
qdt = QDateTime(dt)
qdt.setTimeZone(QTimeZone.utc())
return qdt
self.date_from.setDateTimeRange(utc_dt(min_dt), utc_dt(max_dt))
self.date_to.setDateTimeRange(utc_dt(min_dt2), utc_dt(max_dt2))
self.date_from.setDisplayFormat(date_format)
self.date_to.setDisplayFormat(date_format)
def format_time(i):
dt = QDateTime.fromMSecsSinceEpoch(i * 1000).toUTC()
return dt.toString(date_format)
self.slider.setFormatter(format_time)
@classmethod
def migrate_settings(cls, settings_, version):
if version < 2:
interval = settings_["playback_interval"] / 1000
if interval in cls.DELAY_VALUES:
settings_["playback_interval"] = interval
else:
settings_["playback_interval"] = 1
class CanvasView(QGraphicsView):
"""Canvas View handles the zooming.
"""
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.__backgroundIcon = QIcon()
self.__autoScroll = False
self.__autoScrollMargin = 16
self.__autoScrollTimer = QTimer(self)
self.__autoScrollTimer.timeout.connect(self.__autoScrollAdvance)
def setScene(self, scene):
QGraphicsView.setScene(self, scene)
self._ensureSceneRect(scene)
def _ensureSceneRect(self, scene):
r = scene.addRect(QRectF(0, 0, 400, 400))
scene.sceneRect()
scene.removeItem(r)
def setAutoScrollMargin(self, margin):
self.__autoScrollMargin = margin
def autoScrollMargin(self):
return self.__autoScrollMargin
def setAutoScroll(self, enable):
self.__autoScroll = enable
def autoScroll(self):
return self.__autoScroll
def mousePressEvent(self, event):
QGraphicsView.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
if not self.__autoScrollTimer.isActive() and \
self.__shouldAutoScroll(event.pos()):
self.__startAutoScroll()
QGraphicsView.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if event.button() & Qt.LeftButton:
self.__stopAutoScroll()
return QGraphicsView.mouseReleaseEvent(self, event)
def __shouldAutoScroll(self, pos):
if self.__autoScroll:
margin = self.__autoScrollMargin
viewrect = self.contentsRect()
rect = viewrect.adjusted(margin, margin, -margin, -margin)
# only do auto scroll when on the viewport's margins
return not rect.contains(pos) and viewrect.contains(pos)
else:
return False
def __startAutoScroll(self):
self.__autoScrollTimer.start(10)
log.debug("Auto scroll timer started")
def __stopAutoScroll(self):
if self.__autoScrollTimer.isActive():
self.__autoScrollTimer.stop()
log.debug("Auto scroll timer stopped")
def __autoScrollAdvance(self):
"""Advance the auto scroll
"""
pos = QCursor.pos()
pos = self.mapFromGlobal(pos)
margin = self.__autoScrollMargin
vvalue = self.verticalScrollBar().value()
hvalue = self.horizontalScrollBar().value()
vrect = QRect(0, 0, self.width(), self.height())
# What should be the speed
advance = 10
# We only do auto scroll if the mouse is inside the view.
if vrect.contains(pos):
if pos.x() < vrect.left() + margin:
self.horizontalScrollBar().setValue(hvalue - advance)
if pos.y() < vrect.top() + margin:
self.verticalScrollBar().setValue(vvalue - advance)
if pos.x() > vrect.right() - margin:
self.horizontalScrollBar().setValue(hvalue + advance)
if pos.y() > vrect.bottom() - margin:
self.verticalScrollBar().setValue(vvalue + advance)
if self.verticalScrollBar().value() == vvalue and \
self.horizontalScrollBar().value() == hvalue:
self.__stopAutoScroll()
else:
self.__stopAutoScroll()
log.debug("Auto scroll advance")
def setBackgroundIcon(self, icon):
if not isinstance(icon, QIcon):
raise TypeError("A QIcon expected.")
if self.__backgroundIcon != icon:
self.__backgroundIcon = icon
self.viewport().update()
def backgroundIcon(self):
return QIcon(self.__backgroundIcon)
def drawBackground(self, painter, rect):
QGraphicsView.drawBackground(self, painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
class CanvasView(QGraphicsView):
"""Canvas View handles the zooming.
"""
def __init__(self, *args):
super().__init__(*args)
self.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.grabGesture(Qt.PinchGesture)
self.__backgroundIcon = QIcon()
self.__autoScroll = False
self.__autoScrollMargin = 16
self.__autoScrollTimer = QTimer(self)
self.__autoScrollTimer.timeout.connect(self.__autoScrollAdvance)
# scale factor accumulating partial increments from wheel events
self.__zoomLevel = 100
# effective scale level(rounded to whole integers)
self.__effectiveZoomLevel = 100
self.__zoomInAction = QAction(
self.tr("Zoom in"),
self,
objectName="action-zoom-in",
shortcut=QKeySequence.ZoomIn,
triggered=self.zoomIn,
)
self.__zoomOutAction = QAction(self.tr("Zoom out"),
self,
objectName="action-zoom-out",
shortcut=QKeySequence.ZoomOut,
triggered=self.zoomOut)
self.__zoomResetAction = QAction(
self.tr("Reset Zoom"),
self,
objectName="action-zoom-reset",
triggered=self.zoomReset,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0))
def setScene(self, scene):
super().setScene(scene)
self._ensureSceneRect(scene)
def _ensureSceneRect(self, scene):
r = scene.addRect(QRectF(0, 0, 400, 400))
scene.sceneRect()
scene.removeItem(r)
def setAutoScrollMargin(self, margin):
self.__autoScrollMargin = margin
def autoScrollMargin(self):
return self.__autoScrollMargin
def setAutoScroll(self, enable):
self.__autoScroll = enable
def autoScroll(self):
return self.__autoScroll
def mousePressEvent(self, event):
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
if not self.__autoScrollTimer.isActive() and \
self.__shouldAutoScroll(event.pos()):
self.__startAutoScroll()
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if event.button() & Qt.LeftButton:
self.__stopAutoScroll()
return super().mouseReleaseEvent(event)
def __should_scroll_horizontally(self, event: QWheelEvent):
if event.source() != Qt.MouseEventNotSynthesized:
return False
if (event.modifiers() & Qt.ShiftModifier and sys.platform == 'darwin'
or event.modifiers() & Qt.AltModifier
and sys.platform != 'darwin'):
return True
if event.angleDelta().x() == 0:
vBar = self.verticalScrollBar()
yDelta = event.angleDelta().y()
direction = yDelta >= 0
edgeVBarValue = vBar.minimum() if direction else vBar.maximum()
return vBar.value() == edgeVBarValue
return False
def wheelEvent(self, event: QWheelEvent):
# Zoom
if event.modifiers() & Qt.ControlModifier \
and event.buttons() == Qt.NoButton:
delta = event.angleDelta().y()
# use mouse position as anchor while zooming
anchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__setZoomLevel(self.__zoomLevel + 10 * delta / 120)
self.setTransformationAnchor(anchor)
event.accept()
# Scroll horizontally
elif self.__should_scroll_horizontally(event):
x, y = event.angleDelta().x(), event.angleDelta().y()
sign_value = x if x != 0 else y
sign = 1 if sign_value >= 0 else -1
new_angle_delta = QPoint(sign * max(abs(x), abs(y), sign_value), 0)
new_pixel_delta = QPoint(0, 0)
new_modifiers = event.modifiers() & ~(Qt.ShiftModifier
| Qt.AltModifier)
new_event = QWheelEvent(event.pos(), event.globalPos(),
new_pixel_delta, new_angle_delta,
event.buttons(), new_modifiers,
event.phase(), event.inverted(),
event.source())
event.accept()
super().wheelEvent(new_event)
else:
super().wheelEvent(event)
def gestureEvent(self, event: QGestureEvent):
gesture = event.gesture(Qt.PinchGesture)
if gesture is None:
return
if gesture.state() == Qt.GestureStarted:
event.accept(gesture)
elif gesture.changeFlags() & QPinchGesture.ScaleFactorChanged:
anchor = gesture.centerPoint().toPoint()
anchor = self.mapToScene(anchor)
self.__setZoomLevel(self.__zoomLevel * gesture.scaleFactor(),
anchor=anchor)
event.accept()
elif gesture.state() == Qt.GestureFinished:
event.accept()
def event(self, event: QEvent) -> bool:
if event.type() == QEvent.Gesture:
self.gestureEvent(cast(QGestureEvent, event))
return super().event(event)
def zoomIn(self):
self.__setZoomLevel(self.__zoomLevel + 10)
def zoomOut(self):
self.__setZoomLevel(self.__zoomLevel - 10)
def zoomReset(self):
"""
Reset the zoom level.
"""
self.__setZoomLevel(100)
def zoomLevel(self):
# type: () -> float
"""
Return the current zoom level.
Level is expressed in percentages; 100 is unscaled, 50 is half size, ...
"""
return self.__effectiveZoomLevel
def setZoomLevel(self, level):
self.__setZoomLevel(level)
def __setZoomLevel(self, scale, anchor=None):
# type: (float, Optional[QPointF]) -> None
self.__zoomLevel = max(30, min(scale, 300))
scale = round(self.__zoomLevel)
self.__zoomOutAction.setEnabled(scale != 30)
self.__zoomInAction.setEnabled(scale != 300)
if self.__effectiveZoomLevel != scale:
self.__effectiveZoomLevel = scale
transform = QTransform()
transform.scale(scale / 100, scale / 100)
if anchor is not None:
anchor = self.mapFromScene(anchor)
self.setTransform(transform)
if anchor is not None:
center = self.viewport().rect().center()
diff = self.mapToScene(center) - self.mapToScene(anchor)
self.centerOn(anchor + diff)
self.zoomLevelChanged.emit(scale)
zoomLevelChanged = Signal(float)
zoomLevel_ = Property(float,
zoomLevel,
setZoomLevel,
notify=zoomLevelChanged)
def __shouldAutoScroll(self, pos):
if self.__autoScroll:
margin = self.__autoScrollMargin
viewrect = self.contentsRect()
rect = viewrect.adjusted(margin, margin, -margin, -margin)
# only do auto scroll when on the viewport's margins
return not rect.contains(pos) and viewrect.contains(pos)
else:
return False
def __startAutoScroll(self):
self.__autoScrollTimer.start(10)
log.debug("Auto scroll timer started")
def __stopAutoScroll(self):
if self.__autoScrollTimer.isActive():
self.__autoScrollTimer.stop()
log.debug("Auto scroll timer stopped")
def __autoScrollAdvance(self):
"""Advance the auto scroll
"""
pos = QCursor.pos()
pos = self.mapFromGlobal(pos)
margin = self.__autoScrollMargin
vvalue = self.verticalScrollBar().value()
hvalue = self.horizontalScrollBar().value()
vrect = QRect(0, 0, self.width(), self.height())
# What should be the speed
advance = 10
# We only do auto scroll if the mouse is inside the view.
if vrect.contains(pos):
if pos.x() < vrect.left() + margin:
self.horizontalScrollBar().setValue(hvalue - advance)
if pos.y() < vrect.top() + margin:
self.verticalScrollBar().setValue(vvalue - advance)
if pos.x() > vrect.right() - margin:
self.horizontalScrollBar().setValue(hvalue + advance)
if pos.y() > vrect.bottom() - margin:
self.verticalScrollBar().setValue(vvalue + advance)
if self.verticalScrollBar().value() == vvalue and \
self.horizontalScrollBar().value() == hvalue:
self.__stopAutoScroll()
else:
self.__stopAutoScroll()
log.debug("Auto scroll advance")
def setBackgroundIcon(self, icon):
if not isinstance(icon, QIcon):
raise TypeError("A QIcon expected.")
if self.__backgroundIcon != icon:
self.__backgroundIcon = icon
self.viewport().update()
def backgroundIcon(self):
return QIcon(self.__backgroundIcon)
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
class CanvasView(QGraphicsView):
"""Canvas View handles the zooming.
"""
def __init__(self, *args):
super().__init__(*args)
self.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.__backgroundIcon = QIcon()
self.__autoScroll = False
self.__autoScrollMargin = 16
self.__autoScrollTimer = QTimer(self)
self.__autoScrollTimer.timeout.connect(self.__autoScrollAdvance)
# scale factor accumulating partial increments from wheel events
self.__zoomLevel = 100
# effective scale level(rounded to whole integers)
self.__effectiveZoomLevel = 100
self.__zoomInAction = QAction(
self.tr("Zoom in"),
self,
objectName="action-zoom-in",
shortcut=QKeySequence.ZoomIn,
triggered=self.zoomIn,
)
self.__zoomOutAction = QAction(self.tr("Zoom out"),
self,
objectName="action-zoom-out",
shortcut=QKeySequence.ZoomOut,
triggered=self.zoomOut)
self.__zoomResetAction = QAction(
self.tr("Reset Zoom"),
self,
objectName="action-zoom-reset",
triggered=self.zoomReset,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0))
def setScene(self, scene):
super().setScene(scene)
self._ensureSceneRect(scene)
def _ensureSceneRect(self, scene):
r = scene.addRect(QRectF(0, 0, 400, 400))
scene.sceneRect()
scene.removeItem(r)
def setAutoScrollMargin(self, margin):
self.__autoScrollMargin = margin
def autoScrollMargin(self):
return self.__autoScrollMargin
def setAutoScroll(self, enable):
self.__autoScroll = enable
def autoScroll(self):
return self.__autoScroll
def mousePressEvent(self, event):
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
if not self.__autoScrollTimer.isActive() and \
self.__shouldAutoScroll(event.pos()):
self.__startAutoScroll()
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if event.button() & Qt.LeftButton:
self.__stopAutoScroll()
return super().mouseReleaseEvent(event)
def wheelEvent(self, event: QWheelEvent):
if event.modifiers() & Qt.ControlModifier \
and event.buttons() == Qt.NoButton:
delta = event.angleDelta().y()
# use mouse position as anchor while zooming
anchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__setZoomLevel(self.__zoomLevel + 10 * delta / 120)
self.setTransformationAnchor(anchor)
event.accept()
else:
super().wheelEvent(event)
def zoomIn(self):
self.__setZoomLevel(self.__zoomLevel + 10)
def zoomOut(self):
self.__setZoomLevel(self.__zoomLevel - 10)
def zoomReset(self):
"""
Reset the zoom level.
"""
self.__setZoomLevel(100)
def zoomLevel(self):
# type: () -> float
"""
Return the current zoom level.
Level is expressed in percentages; 100 is unscaled, 50 is half size, ...
"""
return self.__effectiveZoomLevel
def setZoomLevel(self, level):
self.__setZoomLevel(level)
def __setZoomLevel(self, scale):
# type: (float) -> None
self.__zoomLevel = max(30, min(scale, 300))
scale = round(self.__zoomLevel)
self.__zoomOutAction.setEnabled(scale != 30)
self.__zoomInAction.setEnabled(scale != 300)
if self.__effectiveZoomLevel != scale:
self.__effectiveZoomLevel = scale
transform = QTransform()
transform.scale(scale / 100, scale / 100)
self.setTransform(transform)
self.zoomLevelChanged.emit(scale)
zoomLevelChanged = Signal(float)
zoomLevel_ = Property(float,
zoomLevel,
setZoomLevel,
notify=zoomLevelChanged)
def __shouldAutoScroll(self, pos):
if self.__autoScroll:
margin = self.__autoScrollMargin
viewrect = self.contentsRect()
rect = viewrect.adjusted(margin, margin, -margin, -margin)
# only do auto scroll when on the viewport's margins
return not rect.contains(pos) and viewrect.contains(pos)
else:
return False
def __startAutoScroll(self):
self.__autoScrollTimer.start(10)
log.debug("Auto scroll timer started")
def __stopAutoScroll(self):
if self.__autoScrollTimer.isActive():
self.__autoScrollTimer.stop()
log.debug("Auto scroll timer stopped")
def __autoScrollAdvance(self):
"""Advance the auto scroll
"""
pos = QCursor.pos()
pos = self.mapFromGlobal(pos)
margin = self.__autoScrollMargin
vvalue = self.verticalScrollBar().value()
hvalue = self.horizontalScrollBar().value()
vrect = QRect(0, 0, self.width(), self.height())
# What should be the speed
advance = 10
# We only do auto scroll if the mouse is inside the view.
if vrect.contains(pos):
if pos.x() < vrect.left() + margin:
self.horizontalScrollBar().setValue(hvalue - advance)
if pos.y() < vrect.top() + margin:
self.verticalScrollBar().setValue(vvalue - advance)
if pos.x() > vrect.right() - margin:
self.horizontalScrollBar().setValue(hvalue + advance)
if pos.y() > vrect.bottom() - margin:
self.verticalScrollBar().setValue(vvalue + advance)
if self.verticalScrollBar().value() == vvalue and \
self.horizontalScrollBar().value() == hvalue:
self.__stopAutoScroll()
else:
self.__stopAutoScroll()
log.debug("Auto scroll advance")
def setBackgroundIcon(self, icon):
if not isinstance(icon, QIcon):
raise TypeError("A QIcon expected.")
if self.__backgroundIcon != icon:
self.__backgroundIcon = icon
self.viewport().update()
def backgroundIcon(self):
return QIcon(self.__backgroundIcon)
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
class CanvasView(QGraphicsView):
"""Canvas View handles the zooming.
"""
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.__backgroundIcon = QIcon()
self.__autoScroll = False
self.__autoScrollMargin = 16
self.__autoScrollTimer = QTimer(self)
self.__autoScrollTimer.timeout.connect(self.__autoScrollAdvance)
def setScene(self, scene):
QGraphicsView.setScene(self, scene)
self._ensureSceneRect(scene)
def _ensureSceneRect(self, scene):
r = scene.addRect(QRectF(0, 0, 400, 400))
scene.sceneRect()
scene.removeItem(r)
def setAutoScrollMargin(self, margin):
self.__autoScrollMargin = margin
def autoScrollMargin(self):
return self.__autoScrollMargin
def setAutoScroll(self, enable):
self.__autoScroll = enable
def autoScroll(self):
return self.__autoScroll
def mousePressEvent(self, event):
QGraphicsView.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
if not self.__autoScrollTimer.isActive() and \
self.__shouldAutoScroll(event.pos()):
self.__startAutoScroll()
QGraphicsView.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if event.button() & Qt.LeftButton:
self.__stopAutoScroll()
return QGraphicsView.mouseReleaseEvent(self, event)
def __shouldAutoScroll(self, pos):
if self.__autoScroll:
margin = self.__autoScrollMargin
viewrect = self.contentsRect()
rect = viewrect.adjusted(margin, margin, -margin, -margin)
# only do auto scroll when on the viewport's margins
return not rect.contains(pos) and viewrect.contains(pos)
else:
return False
def __startAutoScroll(self):
self.__autoScrollTimer.start(10)
log.debug("Auto scroll timer started")
def __stopAutoScroll(self):
if self.__autoScrollTimer.isActive():
self.__autoScrollTimer.stop()
log.debug("Auto scroll timer stopped")
def __autoScrollAdvance(self):
"""Advance the auto scroll
"""
pos = QCursor.pos()
pos = self.mapFromGlobal(pos)
margin = self.__autoScrollMargin
vvalue = self.verticalScrollBar().value()
hvalue = self.horizontalScrollBar().value()
vrect = QRect(0, 0, self.width(), self.height())
# What should be the speed
advance = 10
# We only do auto scroll if the mouse is inside the view.
if vrect.contains(pos):
if pos.x() < vrect.left() + margin:
self.horizontalScrollBar().setValue(hvalue - advance)
if pos.y() < vrect.top() + margin:
self.verticalScrollBar().setValue(vvalue - advance)
if pos.x() > vrect.right() - margin:
self.horizontalScrollBar().setValue(hvalue + advance)
if pos.y() > vrect.bottom() - margin:
self.verticalScrollBar().setValue(vvalue + advance)
if self.verticalScrollBar().value() == vvalue and \
self.horizontalScrollBar().value() == hvalue:
self.__stopAutoScroll()
else:
self.__stopAutoScroll()
log.debug("Auto scroll advance")
def setBackgroundIcon(self, icon):
if not isinstance(icon, QIcon):
raise TypeError("A QIcon expected.")
if self.__backgroundIcon != icon:
self.__backgroundIcon = icon
self.viewport().update()
def backgroundIcon(self):
return QIcon(self.__backgroundIcon)
def drawBackground(self, painter, rect):
QGraphicsView.drawBackground(self, painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(
vrect.size().toSize().boundedTo(QSize(200, 200))
)
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
class WidgetManager(QObject):
"""
WidgetManager class is responsible for creation, tracking and deletion
of UI elements constituting an interactive workflow.
It does so by reacting to changes in the underlying workflow model,
creating and destroying the components when needed.
This is an abstract class, subclassed MUST reimplement at least
:func:`create_widget_for_node` and :func:`delete_widget_for_node`.
The widgets created with :func:`create_widget_for_node` will automatically
receive dispatched events:
* :data:`WorkflowEvent.InputLinkAdded` - when a new input link is
added to the workflow.
* :data:`LinkEvent.InputLinkRemoved` - when a input link is removed.
* :data:`LinkEvent.OutputLinkAdded` - when a new output link is
added to the workflow.
* :data:`LinkEvent.InputLinkRemoved` - when a output link is removed.
* :data:`LinkEvent.InputLinkStateChanged` - when the input link's
runtime state changes.
* :data:`LinkEvent.OutputLinkStateChanged` - when the output link's
runtime state changes.
* :data:`WorkflowEnvEvent.WorkflowEnvironmentChanged` - when the
workflow environment changes.
.. seealso:: :func:`.Scheme.add_link()`, :func:`Scheme.remove_link`,
:func:`.Scheme.runtime_env`
"""
#: A new QWidget was created and added by the manager.
widget_for_node_added = Signal(SchemeNode, QWidget)
#: A QWidget was removed, hidden and will be deleted when appropriate.
widget_for_node_removed = Signal(SchemeNode, QWidget)
class CreationPolicy(enum.Enum):
"""
Widget Creation Policy.
"""
#: Widgets are scheduled to be created from the event loop, or when
#: first accessed with `widget_for_node`
Normal = "Normal"
#: Widgets are created immediately when a node is added to the
#: workflow model.
Immediate = "Immediate"
#: Widgets are created only when first accessed with `widget_for_node`
#: (e.g. when activated in the view).
OnDemand = "OnDemand"
Normal = CreationPolicy.Normal
Immediate = CreationPolicy.Immediate
OnDemand = CreationPolicy.OnDemand
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__workflow = None # type: Optional[Scheme]
self.__creation_policy = WidgetManager.Normal
self.__float_widgets_on_top = False
self.__item_for_node = {} # type: Dict[SchemeNode, Item]
self.__item_for_widget = {} # type: Dict[QWidget, Item]
self.__init_queue = deque() # type: Deque[SchemeNode]
self.__init_timer = QTimer(self, singleShot=True)
self.__init_timer.timeout.connect(self.__process_init_queue)
self.__activation_monitor = ActivationMonitor(self)
self.__activation_counter = itertools.count()
self.__activation_monitor.activated.connect(self.__mark_activated)
def set_workflow(self, workflow):
# type: (Scheme) -> None
"""
Set the workflow.
"""
if workflow is self.__workflow:
return
if self.__workflow is not None:
# cleanup
for node in self.__workflow.nodes:
self.__remove_node(node)
self.__workflow.node_added.disconnect(self.__on_node_added)
self.__workflow.node_removed.disconnect(self.__on_node_removed)
self.__workflow.link_added.disconnect(self.__on_link_added)
self.__workflow.link_removed.disconnect(self.__on_link_removed)
self.__workflow.runtime_env_changed.disconnect(
self.__on_env_changed)
self.__workflow.removeEventFilter(self)
self.__workflow = workflow
workflow.node_added.connect(self.__on_node_added, Qt.UniqueConnection)
workflow.node_removed.connect(self.__on_node_removed,
Qt.UniqueConnection)
workflow.link_added.connect(self.__on_link_added, Qt.UniqueConnection)
workflow.link_removed.connect(self.__on_link_removed,
Qt.UniqueConnection)
workflow.runtime_env_changed.connect(self.__on_env_changed,
Qt.UniqueConnection)
workflow.installEventFilter(self)
for node in workflow.nodes:
self.__add_node(node)
def workflow(self):
# type: () -> Optional[Workflow]
return self.__workflow
scheme = workflow
set_scheme = set_workflow
def set_creation_policy(self, policy):
# type: (CreationPolicy) -> None
"""
Set the widget creation policy.
"""
if self.__creation_policy != policy:
self.__creation_policy = policy
if self.__creation_policy == WidgetManager.Immediate:
self.__init_timer.stop()
# create all
if self.__workflow is not None:
for node in self.__workflow.nodes:
self.ensure_created(node)
elif self.__creation_policy == WidgetManager.Normal:
if not self.__init_timer.isActive() and self.__init_queue:
self.__init_timer.start()
elif self.__creation_policy == WidgetManager.OnDemand:
self.__init_timer.stop()
else:
assert False
def creation_policy(self):
"""
Return the current widget creation policy.
"""
return self.__creation_policy
def create_widget_for_node(self, node):
# type: (SchemeNode) -> QWidget
"""
Create and initialize a widget for node.
This is an abstract method. Subclasses must reimplemented it.
"""
raise NotImplementedError()
def delete_widget_for_node(self, node, widget):
# type: (SchemeNode, QWidget) -> None
"""
Remove and delete widget for node.
This is an abstract method. Subclasses must reimplemented it.
"""
raise NotImplementedError()
def node_for_widget(self, widget):
# type: (QWidget) -> Optional[SchemeNode]
"""
Return the node for widget.
"""
item = self.__item_for_widget.get(widget)
if item is not None:
return item.node
else:
return None
def widget_for_node(self, node):
# type: (SchemeNode) -> Optional[QWidget]
"""
Return the widget for node.
"""
self.ensure_created(node)
item = self.__item_for_node.get(node)
return item.widget if item is not None else None
def __add_widget_for_node(self, node):
# type: (SchemeNode) -> None
item = self.__item_for_node.get(node)
if item is not None:
return
if self.__workflow is None:
return
if node not in self.__workflow.nodes:
return
if node in self.__init_queue:
self.__init_queue.remove(node)
item = Item(node, None, -1)
# Insert on the node -> item mapping.
self.__item_for_node[node] = item
log.debug("Creating widget for node %s", node)
try:
w = self.create_widget_for_node(node)
except Exception: # pylint: disable=broad-except
log.critical("", exc_info=True)
lines = traceback.format_exception(*sys.exc_info())
text = "".join(lines)
errorwidget = QLabel(textInteractionFlags=Qt.TextSelectableByMouse,
wordWrap=True,
objectName="widgetmanager-error-placeholder",
text="<pre>" + escape(text) + "</pre>")
item.errorwidget = errorwidget
node.set_state_message(UserMessage(text, UserMessage.Error, ""))
raise
else:
item.widget = w
self.__item_for_widget[w] = item
self.__set_float_on_top_flag(w)
if w.windowIcon().isNull():
desc = node.description
w.setWindowIcon(icon_loader.from_description(desc).get(desc.icon))
if not w.windowTitle():
w.setWindowTitle(node.title)
w.installEventFilter(self.__activation_monitor)
raise_canvas = QAction(
self.tr("Raise Canvas to Front"),
w,
objectName="action-canvas-raise-canvas",
toolTip=self.tr("Raise containing canvas workflow window"),
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_Up))
raise_canvas.triggered.connect(self.__on_activate_parent)
raise_descendants = QAction(
self.tr("Raise Descendants"),
w,
objectName="action-canvas-raise-descendants",
toolTip=self.tr("Raise all immediate descendants of this node"),
shortcut=QKeySequence(Qt.ControlModifier | Qt.ShiftModifier
| Qt.Key_Right))
raise_descendants.triggered.connect(
partial(self.__on_raise_descendants, node))
raise_ancestors = QAction(
self.tr("Raise Ancestors"),
w,
objectName="action-canvas-raise-ancestors",
toolTip=self.tr("Raise all immediate ancestors of this node"),
shortcut=QKeySequence(Qt.ControlModifier | Qt.ShiftModifier
| Qt.Key_Left))
raise_ancestors.triggered.connect(
partial(self.__on_raise_ancestors, node))
w.addActions([raise_canvas, raise_descendants, raise_ancestors])
# send all the post creation notification events
workflow = self.__workflow
assert workflow is not None
inputs = workflow.find_links(sink_node=node)
for link in inputs:
ev = LinkEvent(LinkEvent.InputLinkAdded, link)
QCoreApplication.sendEvent(w, ev)
outputs = workflow.find_links(source_node=node)
for link in outputs:
ev = LinkEvent(LinkEvent.OutputLinkAdded, link)
QCoreApplication.sendEvent(w, ev)
self.widget_for_node_added.emit(node, w)
def ensure_created(self, node):
# type: (SchemeNode) -> None
"""
Ensure that the widget for node is created.
"""
if self.__workflow is None:
return
if node not in self.__workflow.nodes:
return
item = self.__item_for_node.get(node)
if item is None:
self.__add_widget_for_node(node)
def __on_node_added(self, node):
# type: (SchemeNode) -> None
assert self.__workflow is not None
assert node in self.__workflow.nodes
assert node not in self.__item_for_node
self.__add_node(node)
def __add_node(self, node):
# type: (SchemeNode) -> None
# add node for tracking
node.installEventFilter(self)
if self.__creation_policy == WidgetManager.Immediate:
self.ensure_created(node)
else:
self.__init_queue.append(node)
if self.__creation_policy == WidgetManager.Normal:
self.__init_timer.start()
def __on_node_removed(self, node): # type: (SchemeNode) -> None
assert self.__workflow is not None
assert node not in self.__workflow.nodes
self.__remove_node(node)
def __remove_node(self, node): # type: (SchemeNode) -> None
# remove the node and its widget from tracking.
node.removeEventFilter(self)
if node in self.__init_queue:
self.__init_queue.remove(node)
item = self.__item_for_node.get(node)
if item is not None and item.widget is not None:
widget = item.widget
assert widget in self.__item_for_widget
del self.__item_for_widget[widget]
widget.removeEventFilter(self.__activation_monitor)
item.widget = None
self.widget_for_node_removed.emit(node, widget)
self.delete_widget_for_node(node, widget)
if item is not None:
del self.__item_for_node[node]
@Slot()
def __process_init_queue(self):
if self.__init_queue:
node = self.__init_queue.popleft()
assert self.__workflow is not None
assert node in self.__workflow.nodes
log.debug("__process_init_queue: '%s'", node.title)
try:
self.ensure_created(node)
finally:
if self.__init_queue:
self.__init_timer.start()
def __on_link_added(self, link): # type: (SchemeLink) -> None
assert self.__workflow is not None
assert link.source_node in self.__workflow.nodes
assert link.sink_node in self.__workflow.nodes
source = self.__item_for_node.get(link.source_node)
sink = self.__item_for_node.get(link.sink_node)
# notify the node gui of an added link
if source is not None and source.widget is not None:
ev = LinkEvent(LinkEvent.OutputLinkAdded, link)
QCoreApplication.sendEvent(source.widget, ev)
if sink is not None and sink.widget is not None:
ev = LinkEvent(LinkEvent.InputLinkAdded, link)
QCoreApplication.sendEvent(sink.widget, ev)
def __on_link_removed(self, link): # type: (SchemeLink) -> None
assert self.__workflow is not None
assert link.source_node in self.__workflow.nodes
assert link.sink_node in self.__workflow.nodes
source = self.__item_for_node.get(link.source_node)
sink = self.__item_for_node.get(link.sink_node)
# notify the node gui of an removed link
if source is not None and source.widget is not None:
ev = LinkEvent(LinkEvent.OutputLinkRemoved, link)
QCoreApplication.sendEvent(source.widget, ev)
if sink is not None and sink.widget is not None:
ev = LinkEvent(LinkEvent.InputLinkRemoved, link)
QCoreApplication.sendEvent(sink.widget, ev)
def __mark_activated(self, widget): # type: (QWidget) -> None
# Update the tracked stacking order for `widget`
item = self.__item_for_widget.get(widget)
if item is not None:
item.activation_order = next(self.__activation_counter)
def activate_widget_for_node(self, node, widget):
# type: (SchemeNode, QWidget) -> None
"""
Activate the widget for node (show and raise above other)
"""
if widget.windowState() == Qt.WindowMinimized:
widget.showNormal()
widget.setVisible(True)
widget.raise_()
widget.activateWindow()
def activate_window_group(self, group):
# type: (Scheme.WindowGroup) -> None
self.restore_window_state(group.state)
def raise_widgets_to_front(self):
"""
Raise all current visible widgets to the front.
The widgets will be stacked by activation order.
"""
workflow = self.__workflow
if workflow is None:
return
items = filter(
lambda item:
(item.widget.isVisible()
if item is not None and item.widget is not None else False),
map(self.__item_for_node.get, workflow.nodes))
self.__raise_and_activate(items)
def set_float_widgets_on_top(self, float_on_top):
"""
Set `Float Widgets on Top` flag on all widgets.
"""
self.__float_widgets_on_top = float_on_top
for item in self.__item_for_node.values():
if item.widget is not None:
self.__set_float_on_top_flag(item.widget)
def save_window_state(self):
# type: () -> List[Tuple[SchemeNode, bytes]]
"""
Save current open window arrangement.
"""
if self.__workflow is None:
return []
workflow = self.__workflow # type: Scheme
state = []
for node in workflow.nodes: # type: SchemeNode
item = self.__item_for_node.get(node, None)
if item is None:
continue
stackorder = item.activation_order
if item.widget is not None and not item.widget.isHidden():
data = self.save_widget_geometry(node, item.widget)
state.append((stackorder, node, data))
return [(node, data)
for _, node, data in sorted(state, key=lambda t: t[0])]
def restore_window_state(self, state):
# type: (List[Tuple[Node, bytes]]) -> None
"""
Restore the window state.
"""
assert self.__workflow is not None
workflow = self.__workflow # type: Scheme
visible = {node for node, _ in state}
# first hide all other widgets
for node in workflow.nodes:
if node not in visible:
# avoid creating widgets if not needed
item = self.__item_for_node.get(node, None)
if item is not None and item.widget is not None:
item.widget.hide()
allnodes = set(workflow.nodes)
# restore state for visible group; windows are stacked as they appear
# in the state list.
w = None
for node, node_state in filter(lambda t: t[0] in allnodes, state):
w = self.widget_for_node(node) # also create it if needed
if w is not None:
w.show()
self.restore_widget_geometry(node, w, node_state)
w.raise_()
self.__mark_activated(w)
# activate (give focus to) the last window
if w is not None:
w.activateWindow()
def save_widget_geometry(self, node, widget):
# type: (SchemeNode, QWidget) -> bytes
"""
Save and return the current geometry and state for node.
"""
return b''
def restore_widget_geometry(self, node, widget, state):
# type: (SchemeNode, QWidget, bytes) -> bool
"""
Restore the widget geometry and state for node.
Return True if the geometry was restored successfully.
The default implementation does nothing.
"""
return False
@Slot(SchemeNode)
def __on_raise_ancestors(self, node):
# type: (SchemeNode) -> None
"""
Raise all the ancestor widgets of `widget`.
"""
item = self.__item_for_node.get(node)
if item is not None:
scheme = self.scheme()
assert scheme is not None
ancestors = [
self.__item_for_node.get(p) for p in scheme.parents(item.node)
]
self.__raise_and_activate(filter(None, reversed(ancestors)))
@Slot(SchemeNode)
def __on_raise_descendants(self, node):
# type: (SchemeNode) -> None
"""
Raise all the descendants widgets of `widget`.
"""
item = self.__item_for_node.get(node)
if item is not None:
scheme = self.scheme()
assert scheme is not None
descendants = [
self.__item_for_node.get(p) for p in scheme.children(item.node)
]
self.__raise_and_activate(filter(None, reversed(descendants)))
def __raise_and_activate(self, items):
# type: (Iterable[Item]) -> None
"""Show and raise a set of widgets."""
# preserve the tracked stacking order
items = sorted(items, key=lambda item: item.activation_order)
w = None
for item in items:
if item.widget is not None:
w = item.widget
elif item.errorwidget is not None:
w = item.errorwidget
else:
continue
w.show()
w.raise_()
if w is not None:
# give focus to the last activated top window
w.activateWindow()
def __activate_widget_for_node(self, node): # type: (SchemeNode) -> None
# activate the widget for the node.
self.ensure_created(node)
item = self.__item_for_node.get(node)
if item is None:
return
if item.widget is not None:
self.activate_widget_for_node(node, item.widget)
elif item.errorwidget is not None:
item.errorwidget.show()
item.errorwidget.raise_()
item.errorwidget.activateWindow()
def __on_activate_parent(self):
event = WorkflowEvent(WorkflowEvent.ActivateParentRequest)
QCoreApplication.sendEvent(self.scheme(), event)
def eventFilter(self, recv, event):
# type: (QObject, QEvent) -> bool
if isinstance(recv, SchemeNode):
if event.type() == NodeEvent.NodeActivateRequest:
self.__activate_widget_for_node(recv)
self.__dispatch_events(recv, event)
return False
def __dispatch_events(self, node: Node, event: QEvent) -> None:
"""
Dispatch relevant workflow events to the GUI widget
"""
if event.type() in (
WorkflowEvent.InputLinkAdded,
WorkflowEvent.InputLinkRemoved,
WorkflowEvent.InputLinkStateChange,
WorkflowEvent.OutputLinkAdded,
WorkflowEvent.OutputLinkRemoved,
WorkflowEvent.OutputLinkStateChange,
WorkflowEvent.NodeStateChange,
WorkflowEvent.WorkflowEnvironmentChange,
):
item = self.__item_for_node.get(node)
if item is not None and item.widget is not None:
QCoreApplication.sendEvent(item.widget, event)
def __set_float_on_top_flag(self, widget):
# type: (QWidget) -> None
"""Set or unset widget's float on top flag"""
should_float_on_top = self.__float_widgets_on_top
float_on_top = bool(widget.windowFlags() & Qt.WindowStaysOnTopHint)
if float_on_top == should_float_on_top:
return
widget_was_visible = widget.isVisible()
if should_float_on_top:
widget.setWindowFlags(widget.windowFlags()
| Qt.WindowStaysOnTopHint)
else:
widget.setWindowFlags(widget.windowFlags()
& ~Qt.WindowStaysOnTopHint)
# Changing window flags hid the widget
if widget_was_visible:
widget.show()
def __on_env_changed(self, key, newvalue, oldvalue):
# Notify widgets of a runtime environment change
for item in self.__item_for_node.values():
if item.widget is not None:
ev = WorkflowEnvChanged(key, newvalue, oldvalue)
QCoreApplication.sendEvent(item.widget, ev)
def actions_for_context_menu(self, node):
# type: (SchemeNode) -> List[QAction]
"""
Return a list of extra actions that can be inserted into context
menu in the workflow editor.
Subclasses can reimplement this method to extend the default context
menu.
Parameters
----------
node: SchemeNode
The node for which the context menu is requested.
Return
------
actions: List[QAction]
Actions that are appended to the default menu.
"""
return []
class TrialTimeline(BaseWidget):
COL_MSGTYPE = 0
COL_PCTIME = 1
COL_INITTIME = 2
COL_FINALTIME = 3
COL_MSG = 4
COL_INFO = 5
def __init__(self, session: Session):
BaseWidget.__init__(self, session.name)
self.set_margin(5)
self.session = session
self._reload = ControlButton('Reload')
self._graph = ControlMatplotlib('Value')
self._timer = QTimer()
self._timer.timeout.connect(self.update)
self._read = 0
self._deltas = None
self._last_trial_end = None
self._states_dict = {}
self._trials_list = []
self.formset = ['_graph']
self.colors = list(mcolors.CSS4_COLORS.values())
self._graph.on_draw = self.__on_draw_evt
self._reload.value = self.__reload_evt
def __reload_evt(self):
if self._timer.isActive():
self._timer.stop()
else:
self._timer.start(conf.TRIALTIMELINE_PLUGIN_REFRESH_RATE)
def show(self, detached=False):
if self.session.is_running and self.session.setup.detached:
return
# Prevent the call to be recursive because of the mdi_area
if not detached:
if hasattr(self, '_show_called'):
BaseWidget.show(self)
return
self._show_called = True
self.mainwindow.mdi_area += self
del self._show_called
else:
BaseWidget.show(self)
self._stop = False # flag used to close the gui in the middle of a loading
if not self._stop and self.session.is_running:
self._timer.start(conf.TRIALTIMELINE_PLUGIN_REFRESH_RATE)
self.update()
def hide(self):
self._timer.stop()
self._stop = True
def read_data(self):
res = self.session.data.query(
"TYPE in ['END-TRIAL', 'STATE'] or (TYPE == 'INFO' and MSG in ['SESSION-ENDED','TRIAL-BPOD-TIME'])"
)
for index, msg in res.iterrows():
if index <= self._read: continue
if msg[self.COL_MSGTYPE] == EndTrial.MESSAGE_TYPE_ALIAS:
if self._deltas is not None:
self._trials_list.append(self._deltas)
self._deltas = {}
elif msg[self.COL_MSGTYPE] == StateOccurrence.MESSAGE_TYPE_ALIAS:
state = msg[self.COL_MSG]
delta = float(msg[self.COL_FINALTIME]) - float(
msg[self.COL_INITTIME])
if state not in self._deltas:
# count, delta sum, min delta, max delta
self._deltas[state] = [delta]
self._states_dict[state] = True
else:
self._deltas[state].append(delta)
elif msg[self.COL_MSGTYPE] == SessionInfo.MESSAGE_TYPE_ALIAS and \
msg[self.COL_MSG] == APISession.INFO_SESSION_ENDED:
if self._deltas is not None:
self._trials_list.append(self._deltas)
elif msg[self.COL_MSGTYPE] == SessionInfo.MESSAGE_TYPE_ALIAS and \
msg[self.COL_MSG] == APISession.INFO_TRIAL_BPODTIME:
trial_start = msg[self.COL_INITTIME]
trial_end = msg[self.COL_FINALTIME]
if self._last_trial_end is not None:
delta = float(trial_start) - float(self._last_trial_end)
self._deltas['Init lagging'] = [delta]
self._states_dict['Init lagging'] = True
self._last_trial_end = trial_end
self._read = index
def __on_draw_evt(self, figure):
try:
axes = figure.add_subplot(111)
axes.clear()
trials_labels = []
states_labels = list(self._states_dict.keys())
num_states = len(self._states_dict)
num_trials = len(self._trials_list)
data = np.zeros((num_states, num_trials))
errors = np.zeros((num_states, num_trials))
for i, states in enumerate(self._trials_list):
trials_labels.append('Trial {0}'.format(i))
for j, state_label in enumerate(states_labels):
state_data = states.get(state_label, None)
if state_data is not None:
data[j][i] = np.mean(state_data)
errors[j][i] = np.std(state_data)
colors = {}
offset = np.zeros(len(trials_labels))
trials_indexes = np.array(range(len(trials_labels)))
for i, states_data in enumerate(data):
if len(states_data) == 0: continue
state_label = states_labels[i]
if state_label not in colors:
colors[state_label] = self.colors[len(colors)]
axes.barh(trials_indexes,
states_data,
height=0.8,
color=colors[state_label],
left=offset,
label=state_label,
yerr=errors[i])
offset = offset + states_data
axes.set_yticks(trials_indexes)
axes.set_yticklabels(trials_labels)
axes.set_ylabel('Trials')
axes.set_xlabel('Time (sec)')
axes.legend(loc="upper right")
self._graph.repaint()
except:
self.critical(traceback.format_exc(), 'An error occurred')
'''Takes care of all the session data and transforms it in a graph to be shown in the GUI'''
def update(self):
if not self.session.is_running:
self._timer.stop()
self.read_data()
self._graph.draw()
@property
def mainwindow(self):
return self.session.mainwindow
@property
def title(self):
return BaseWidget.title.fget(self)
@title.setter
def title(self, value):
BaseWidget.title.fset(self, 'Trial Timeline: {0}'.format(value))
