def setup(self, registrar: PartRegistrar) -> None:
attr = TableMeta.from_table(
SequencerTable,
"Sequencer Table",
writeable=list(
SequencerTable.call_types)).create_attribute_model()
self.table_set = MagicMock(side_effect=attr.set_value)
registrar.add_attribute_model("table", attr, self.table_set)
for suff, val in (("a", "INENC1.VAL"), ("b", "INENC2.VAL"), ("c",
"ZERO")):
attr = StringMeta("Input").create_attribute_model(val)
registrar.add_attribute_model(f"pos{suff}", attr)
attr = StringMeta("Input").create_attribute_model("ZERO")
registrar.add_attribute_model("bita", attr)
attr = BooleanMeta("Active", (), True).create_attribute_model(False)
registrar.add_attribute_model("active", attr, attr.set_value)
attr = NumberMeta("int16", "repeats",
writeable=True).create_attribute_model(1)
registrar.add_attribute_model("repeats",
attr,
writeable_func=attr.set_value)
attr = NumberMeta("int16", "prescale",
writeable=True).create_attribute_model(0)
registrar.add_attribute_model("prescale",
attr,
writeable_func=attr.set_value)
class TestAttribute(unittest.TestCase):
def setUp(self):
self.data = StringMeta().create_attribute_model()
self.data.set_notifier_path(Mock(), ["block", "attr"])
self.controller = Mock()
self.context = Mock()
self.o = Attribute(self.controller, self.context, self.data)
def test_init(self):
self.assertIsInstance(self.o, Attribute)
assert hasattr(self.o, "meta")
assert hasattr(self.o, "value")
assert hasattr(self.o, "subscribe_value")
def test_put(self):
self.o.put_value(32)
self.context.put.assert_called_once_with(["block", "attr", "value"],
32,
timeout=None)
def test_put_async(self):
f = self.o.put_value_async(32)
self.context.put_async.assert_called_once_with(
["block", "attr", "value"], 32)
assert f == self.context.put_async.return_value
def test_repr(self):
self.context.make_view.return_value = "foo"
assert repr(self.o) == "<Attribute value='foo'>"
self.context.make_view.assert_called_once_with(self.controller,
self.data, "value")
class AsynSourcePortPart(Part):
"""Defines a string `Attribute` representing a asyn port that should be
depicted as an Source Port on a Block"""
def __init__(
self,
name, # type: ca.util.APartName
description, # type: ca.util.AMetaDescription
rbv, # type: ca.util.ARbv
port_type, # type: APortType
group=None # type: ca.util.AGroup
):
# type: (...) -> None
super(AsynSourcePortPart, self).__init__(name)
self.port_type = port_type
self.meta = StringMeta(description)
self.caa = ca.util.CAAttribute(self.meta,
ca.util.catools.DBR_STRING,
rbv=rbv,
group=group,
on_connect=self.update_tags)
def setup(self, registrar):
# type: (PartRegistrar) -> None
self.caa.setup(registrar, self.name, self.register_hooked)
def update_tags(self, value):
# type: (Any) -> None
# Add the Source Port tags
old_tags = self.meta.tags
new_tags = self.port_type.with_source_port_tag(old_tags,
connected_value=value)
if old_tags != new_tags:
self.meta.set_tags(new_tags)
def __init__(self, value):
# type: (Value) -> None
super(TitlePart, self).__init__("label")
meta = StringMeta("Label for the block")
set_tags(meta, writeable=True)
self.attr = meta.create_attribute_model()
self.registrar = None # type: PartRegistrar
self.initial_value = value
def __init__(self, mri, description=""):
# type: (AMri, ADescription) -> None
super(BasicController, self).__init__(mri, description)
self._faults = {} # Dict[Part, Alarm]
self.info_registry.add_reportable(TitleInfo, self.update_title)
self.info_registry.add_reportable(HealthInfo, self.update_health)
self.health = StringMeta(
"Displays OK or an error message", tags=[Widget.TEXTUPDATE.tag()]
).create_attribute_model("OK")
self.field_registry.add_attribute_model("health", self.health)
def __init__(self, svg: ASvg = "") -> None:
super().__init__("icon")
meta = StringMeta("SVG icon for the Block")
set_tags(meta, widget=Widget.ICON)
try:
with open(svg) as f:
self.svg_text = f.read()
except IOError:
self.svg_text = "<svg/>"
self.attr = meta.create_attribute_model(self.svg_text)
def __init__(
self,
help_url: AHelpUrl,
name: APartName = "help",
description: ADesc = "Help documentation for the Block",
) -> None:
super().__init__(name)
meta = StringMeta(description)
set_tags(meta, widget=Widget.HELP)
self.attr = meta.create_attribute_model(help_url)
def __init__(self, name: parts.APartName, ioc: AIoc) -> None:
super().__init__(name)
self.dls_ver_pv = ca.util.CAAttribute(
StringMeta("IOC version"),
ca.util.catools.DBR_STRING,
"",
ioc + ":DLSVER",
throw=False,
callback=self.version_updated,
)
self.dir1_pv = ca.util.CAAttribute(
StringMeta("IOC directory pt1"),
ca.util.catools.DBR_STRING,
"",
ioc + ":APP_DIR1",
widget=Widget.NONE,
throw=False,
callback=self.set_dir1,
)
self.dir2_pv = ca.util.CAAttribute(
StringMeta("IOC directory pt2"),
ca.util.catools.DBR_STRING,
"",
ioc + ":APP_DIR2",
widget=Widget.NONE,
throw=False,
callback=self.set_dir2,
)
self.autosave_status_pv = ca.util.CAAttribute(
StringMeta("IOC Status"),
ca.util.catools.DBR_STRING,
"",
ioc + ":STATUS",
throw=False,
callback=self.set_procserv_state,
)
self.dir1 = None
self.dir2 = None
self.dir = ""
self.has_procserv = False
elements = OrderedDict()
elements["module"] = StringArrayMeta("Module", tags=[Widget.TEXTUPDATE.tag()])
elements["path"] = StringArrayMeta("Path", tags=[Widget.TEXTUPDATE.tag()])
self.dependencies = TableMeta(
"Modules which this IOC depends on",
tags=[Widget.TABLE.tag()],
writeable=False,
elements=elements,
).create_attribute_model({"module": [], "path": []})
def setup(self, registrar: PartRegistrar) -> None:
super(PortsPart, self).setup(registrar)
attr = StringMeta(tags=[Port.INT32.sink_port_tag(""),
config_tag(1)]).create_attribute_model()
registrar.add_attribute_model("sinkportConnector", attr,
attr.set_value)
attr = StringMeta(tags=[Port.INT32.source_port_tag(self.name)
]).create_attribute_model()
registrar.add_attribute_model("sourceportConnector", attr,
attr.set_value)
def __init__(self,
name: APartName,
rbv: ARbv,
group: AGroup = None) -> None:
super().__init__(name)
meta = StringMeta("CS Axis")
builtin.util.set_tags(meta, group=group, sink_port=Port.MOTOR)
self.rbv = rbv
self.attr = meta.create_attribute_model()
# Subscriptions
self.monitor = None
def __init__(self, name, rbv, group=None):
# type: (ca.util.APartName, ca.util.ARbv, ca.util.AGroup) -> None
super(CompoundMotorCSPart, self).__init__(name)
meta = StringMeta("CS Axis")
builtin.util.set_tags(meta, group=group, sink_port=Port.MOTOR)
self.rbv = rbv
self.attr = meta.create_attribute_model()
# Subscriptions
self.monitor = None
# Hooks
self.register_hooked(builtin.hooks.DisableHook, self.disconnect)
self.register_hooked((builtin.hooks.InitHook, builtin.hooks.ResetHook),
self.reconnect)
def setup(self, registrar: PartRegistrar) -> None:
attr = TableMeta.from_table(
SequencerTable,
"Sequencer Table",
writeable=list(
SequencerTable.call_types)).create_attribute_model()
self.table_set = MagicMock(side_effect=attr.set_value)
registrar.add_attribute_model("table", attr, self.table_set)
for suff, val in (("a", "INENC1.VAL"), ("b", "INENC2.VAL"), ("c",
"ZERO")):
attr = StringMeta("Input").create_attribute_model(val)
registrar.add_attribute_model("pos%s" % suff, attr)
attr = StringMeta("Input").create_attribute_model("ZERO")
registrar.add_attribute_model("bita", attr)
def __init__(
self,
name: APartName,
description: AMetaDescription,
writeable: AWriteable = True,
config: AConfig = 1,
group: AGroup = None,
widget: AWidget = None,
value: AValue = "",
) -> None:
super().__init__(name)
meta = StringMeta(description)
set_tags(meta, writeable, config, group, widget, sink_port=Port.BLOCK)
self.attr = meta.create_attribute_model(value)
self.writeable_func = self.attr.set_value if writeable else None
class TestAttribute(unittest.TestCase):
def setUp(self):
self.meta = StringMeta()
self.o = self.meta.create_attribute_model()
def test_init(self):
self.assertIs(self.o.meta, self.meta)
assert self.o.value == ""
assert self.o.typeid == "epics:nt/NTScalar:1.0"
def test_set_value(self):
value = "test_value"
self.o.set_value(value)
assert self.o.value == value
def test_set_alarm(self):
alarm = Alarm(AlarmSeverity.MAJOR_ALARM, AlarmStatus.DEVICE_STATUS,
"bad")
self.o.set_alarm(alarm)
assert self.o.alarm == alarm
def test_set_timeStamp(self):
timeStamp = TimeStamp()
self.o.set_timeStamp(timeStamp)
assert self.o.timeStamp == timeStamp
def __init__(
self,
name, # type: APartName
description, # type: AMetaDescription
writeable=False, # type: AWriteable
config=1, # type: AConfig
group=None, # type: AGroup
widget=None, # type: AWidget
value="", # type: Value
):
# type: (...) -> None
super(StringPart, self).__init__(name)
meta = StringMeta(description)
set_tags(meta, writeable, config, group, widget)
self.attr = meta.create_attribute_model(value)
self.writeable_func = self.attr.set_value if writeable else None
def __init__(self,
pv_prefix: APvPrefix,
group: ca.util.AGroup = None) -> None:
super().__init__("sinkPorts")
self.pvs = [pv_prefix + ":CsPort", pv_prefix + ":CsAxis"]
self.rbvs = [
pv_prefix + ":CsPort_RBV",
pv_prefix + ":CsAxis_RBV",
pv_prefix + ".OUT",
]
meta = ChoiceMeta("CS Axis")
builtin.util.set_tags(meta,
writeable=True,
group=group,
sink_port=Port.MOTOR)
self.cs_attr = meta.create_attribute_model()
meta = StringMeta("Parent PMAC Port name")
builtin.util.set_tags(meta, group=group, sink_port=Port.MOTOR)
self.pmac_attr = meta.create_attribute_model()
meta = NumberMeta("int32", "Parent PMAC Axis number")
builtin.util.set_tags(meta, group=group)
self.axis_num_attr = meta.create_attribute_model()
# Subscriptions
self.monitors: List = []
self.port = None
self.axis = None
self.port_choices: List = []
def setUp(self):
self.serialized = OrderedDict()
self.serialized["typeid"] = "epics:nt/NTScalar:1.0"
self.serialized["value"] = "some string"
self.serialized["alarm"] = Alarm().to_dict()
self.serialized["timeStamp"] = TimeStamp().to_dict()
self.serialized["meta"] = StringMeta("desc").to_dict()
def __init__(
self,
name: util.APartName,
description: util.AMetaDescription,
pv: util.APv = "",
rbv: util.ARbv = "",
rbv_suffix: util.ARbvSuffix = "",
min_delta: util.AMinDelta = 0.05,
timeout: util.ATimeout = DEFAULT_TIMEOUT,
sink_port: util.ASinkPort = None,
widget: util.AWidget = None,
group: util.AGroup = None,
config: util.AConfig = True,
) -> None:
super().__init__(name)
self.caa = util.CAAttribute(
StringMeta(description),
util.catools.DBR_CHAR_STR,
pv,
rbv,
rbv_suffix,
min_delta,
timeout,
sink_port,
widget,
group,
config,
)
def setup(self, registrar: PartRegistrar) -> None:
self.my_attribute = StringMeta(description="MyString").create_attribute_model(
"hello_block"
)
registrar.add_attribute_model(
"myAttribute", self.my_attribute, self.my_attribute.set_value
)
registrar.add_method_model(self.method)
def __init__(
self,
name, # type: ca.util.APartName
description, # type: ca.util.AMetaDescription
rbv, # type: ca.util.ARbv
port_type, # type: APortType
group=None # type: ca.util.AGroup
):
# type: (...) -> None
super(AsynSourcePortPart, self).__init__(name)
self.port_type = port_type
self.meta = StringMeta(description)
self.caa = ca.util.CAAttribute(self.meta,
ca.util.catools.DBR_STRING,
rbv=rbv,
group=group,
on_connect=self.update_tags)
def setUp(self):
self.data = BlockModel()
self.data.set_endpoint_data("attr",
StringMeta().create_attribute_model())
self.data.set_endpoint_data("method", MethodModel())
self.data.set_notifier_path(Mock(), ["block"])
self.controller = Mock()
self.context = Mock()
self.o = make_view(self.controller, self.context, self.data)
def setup(self, registrar: PartRegistrar) -> None:
self.caa.setup(registrar, self.name, self.register_hooked)
# Add 9 compound motor attributes
for k in CS_AXIS_NAMES + ["I"]:
# Note no widget tag as we don't want it on the properties pane,
# just the layout view
v = StringMeta(
f"Axis Source Port value {k}").create_attribute_model()
self.axis_attrs[k] = v
registrar.add_attribute_model(k.lower(), v)
def __init__(
self,
name: APartName,
initial_windows_drive_letter: ADriveLetter,
initial_path_prefix: APathPrefix = "/dls",
initial_network_prefix: ANetworkPrefix = "",
) -> None:
super().__init__(name)
self.windows_drive_letter = StringMeta(
drive_letter_desc,
tags=[Widget.TEXTINPUT.tag(), config_tag()],
).create_attribute_model(initial_windows_drive_letter)
self.path_prefix = StringMeta(
path_prefix_desc,
tags=[Widget.TEXTINPUT.tag(), config_tag()],
).create_attribute_model(initial_path_prefix)
self.network_prefix = StringMeta(
network_prefix_desc,
tags=[Widget.TEXTINPUT.tag(), config_tag()],
).create_attribute_model(initial_network_prefix)
def __init__(self, ioc: AIoc, initial_svg: builtin.parts.ASvg) -> None:
self.initial_svg = initial_svg
super().__init__(initial_svg)
meta = StringMeta("Host Architecture")
self.host_arch = ca.util.CAAttribute(
meta,
ca.util.catools.DBR_STRING,
"",
ioc + ":KERNEL_VERS",
throw=False,
callback=self.update_icon,
)
def __init__(self, name, rbv, group=None):
# type: (ca.util.APartName, ca.util.ARbv, ca.util.AGroup) -> None
super(CSSourcePortsPart, self).__init__(name)
self.meta = StringMeta("CS Port name")
# This gives the port name
self.caa = ca.util.CAAttribute(self.meta,
ca.util.catools.DBR_STRING,
rbv=rbv,
group=group,
on_connect=self.update_tags)
# These will be the "axis" Source Ports
self.axis_attrs = {}
def setUp(self):
self.serialized = OrderedDict()
self.serialized["typeid"] = "malcolm:core/MethodMeta:1.1"
self.takes = MapMeta()
self.takes.set_elements({"in_attr": StringMeta("desc")})
self.serialized["takes"] = self.takes.to_dict()
self.serialized["defaults"] = OrderedDict({"in_attr": "default"})
self.serialized["description"] = "test_description"
self.serialized["tags"] = []
self.serialized["writeable"] = False
self.serialized["label"] = ""
self.serialized["returns"] = MapMeta().to_dict()
class BasicController(Controller):
"""Basic Controller with Health and Title updating"""
def __init__(self, mri, description=""):
# type: (AMri, ADescription) -> None
super(BasicController, self).__init__(mri, description)
self._faults = {} # Dict[Part, Alarm]
self.info_registry.add_reportable(TitleInfo, self.update_title)
self.info_registry.add_reportable(HealthInfo, self.update_health)
self.health = StringMeta(
"Displays OK or an error message", tags=[Widget.TEXTUPDATE.tag()]
).create_attribute_model("OK")
self.field_registry.add_attribute_model("health", self.health)
def update_title(self, _, info):
# type: (object, TitleInfo) -> None
"""Set the label of the Block Meta object"""
with self._lock:
self._block.meta.set_label(info.title)
def update_health(self, reporter, info):
# type: (object, HealthInfo) -> None
"""Set the health attribute. Called from part"""
with self.changes_squashed:
alarm = info.alarm
if alarm.is_ok():
self._faults.pop(reporter, None)
else:
self._faults[reporter] = alarm
if self._faults:
# Sort them by severity
faults = sorted(self._faults.values(),
key=lambda a: a.severity.value)
alarm = faults[-1]
text = faults[-1].message
else:
alarm = None
text = "OK"
self.health.set_value(text, alarm=alarm)
class TestStringMeta(unittest.TestCase):
def setUp(self):
self.string_meta = StringMeta("test string description")
def test_given_value_str_then_return(self):
response = self.string_meta.validate("TestValue")
assert "TestValue" == response
def test_given_value_int_then_cast_and_return(self):
response = self.string_meta.validate(15)
assert "15" == response
def test_given_value_float_then_cast_and_return(self):
response = self.string_meta.validate(12.8)
assert "12.8" == response
def test_given_value_None_then_return(self):
response = self.string_meta.validate(None)
assert "" == response
def setup(self, registrar: PartRegistrar) -> None:
self.mocks = {}
self.units = {}
for suffix in ["step", "delay", "width", "pulses"]:
# Add an attribute that will be set
attr = NumberMeta("float64").create_attribute_model()
mock = MagicMock(side_effect=attr.set_value)
registrar.add_attribute_model(suffix, attr, mock)
self.mocks[suffix] = mock
if suffix != "pulses":
# Add a units attribute that will be read
units_attr = StringMeta().create_attribute_model("s")
registrar.add_attribute_model(suffix + "Units", units_attr)
self.units[suffix] = units_attr
def __init__(self,
name: APartName,
rbv: ARbv,
group: AGroup = None) -> None:
super().__init__(name)
self.meta = StringMeta("CS Port name")
# This gives the port name
self.caa = ca.util.CAAttribute(
self.meta,
ca.util.catools.DBR_STRING,
rbv=rbv,
group=group,
on_connect=self.update_tags,
)
# These will be the "axis" Source Ports
self.axis_attrs: Dict[str, AttributeModel] = {}
