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] = {}