def send(self, signalName, value, id=None):
# A subclass might still use the old syntax to send outputs
# defined on this class
for _, output in getmembers(self.Outputs, Output):
if output.name == signalName or signalName in output.replaces:
output.send(value, id=id)
return
super().send(signalName, value, id)
def send(self, signalName, value, id=None):
# A subclass might still use the old syntax to send outputs
# defined on this class
for _, output in getmembers(self.Outputs, Output):
if output.name == signalName or signalName in output.replaces:
output.send(value, id=id)
return
super().send(signalName, value, id)
def _check_input_handlers(cls):
unbound = [signal.name
for _, signal in getmembers(cls.Inputs, Input)
if not signal.handler]
if unbound:
raise ValueError("unbound signal(s) in {}: {}".
format(cls.__name__, ", ".join(unbound)))
missing_handlers = [signal.handler for signal in cls.inputs
if not hasattr(cls, signal.handler)]
if missing_handlers:
raise ValueError("missing handlers in {}: {}".
format(cls.__name__, ", ".join(missing_handlers)))
def test_input_handler(self):
widget = self.widget
if not widget:
return
widget.on_new_input = Mock()
inputs = getmembers(widget.Inputs, Input)
self.assertGreaterEqual(len(inputs), 1, msg="Widget defines no inputs")
if len(inputs) > 1:
self.skipTest(
"widget has multiple inputs; input handler can't be tested")
return
handler = getattr(widget, inputs[0][1].handler)
data = Mock()
handler(data)
self.assertIs(widget.data, data)
widget.on_new_input.assert_called()
def get_signals(cls, direction, ignore_old_style=False):
"""
Return a list of `InputSignal` or `OutputSignal` needed for the
widget description. For old-style signals, the method returns the
original list. New-style signals are collected into a list.
Parameters
----------
direction (str): `"inputs"` or `"outputs"`
Returns
-------
list of `InputSignal` or `OutputSignal`
"""
old_style = cls.__dict__.get(direction, None)
if old_style and not ignore_old_style:
return old_style
signal_class = getattr(cls, direction.title())
signals = [signal for _, signal in getmembers(signal_class, _Signal)]
return list(sorted(signals, key=lambda s: s._seq_id))
def copy_outputs(template):
result = type("Outputs", (), {})
for name, signal in getmembers(template, Output):
setattr(result, name, deepcopy(signal))
return result
def copy_outputs(template):
result = type("Outputs", (), {})
for name, signal in getmembers(template, Output):
setattr(result, name, deepcopy(signal))
return result
def _bind_outputs(self):
bound_cls = self.Outputs()
for name, signal in getmembers(bound_cls, Output):
setattr(bound_cls, name, signal.bound_signal(self))
setattr(self, "Outputs", bound_cls)
