def test_init(self):
tm = TableMeta("desc")
assert "desc" == tm.description
assert "malcolm:core/TableMeta:1.0" == tm.typeid
assert () == tm.tags
assert False == tm.writeable
assert "" == tm.label
def test_from_dict(self):
tm = TableMeta.from_dict(self.serialized)
assert tm.description == "desc"
assert len(tm.elements) == 1
assert tm.elements["c1"].to_dict() == self.sam.to_dict()
assert tm.tags == ()
assert tm.writeable == True
assert tm.label == "Name"
def create_attribute_models(self):
for data in super(ManagerController, self).create_attribute_models():
yield data
assert os.path.isdir(self.params.configDir), \
"%s is not a directory" % self.params.configDir
if not os.path.isdir(os.path.join(self.params.configDir, ".git")):
# Try and make it a git repo, don't care if it fails
self._run_git_cmd("init")
self._run_git_cmd("commit", "--allow-empty", "-m", "Created repo")
# Create writeable attribute table for the layout info we need
elements = OrderedDict()
elements["name"] = StringArrayMeta("Name of layout part")
elements["mri"] = StringArrayMeta("Malcolm full name of child block")
elements["x"] = NumberArrayMeta(
"float64", "X Coordinate of child block")
elements["y"] = NumberArrayMeta(
"float64", "Y Coordinate of child block")
elements["visible"] = BooleanArrayMeta("Whether child block is visible")
layout_table_meta = TableMeta(
"Layout of child blocks", elements=elements,
tags=[widget("flowgraph")])
layout_table_meta.set_writeable_in(ss.READY)
self.layout = layout_table_meta.create_attribute_model()
yield "layout", self.layout, self.set_layout
# Create writeable attribute for loading an existing layout
design_meta = ChoiceMeta(
"Design name to load", tags=[config(), widget("combo")])
design_meta.set_writeable_in(ss.READY)
self.design = design_meta.create_attribute_model()
yield "design", self.design, self.set_design
# Create writeable attribute table for the exported fields
elements = OrderedDict()
elements["name"] = ChoiceArrayMeta("Name of exported block.field")
elements["exportName"] = StringArrayMeta(
"Name of the field within current block")
exports_table_meta = TableMeta(
"Exported fields of child blocks", tags=[widget("table")],
elements=elements)
exports_table_meta.set_writeable_in(ss.READY)
self.exports = exports_table_meta.create_attribute_model()
yield "exports", self.exports, self.set_exports
# Create read-only indicator for when things are modified
modified_meta = BooleanMeta(
"Whether the design is modified", tags=[widget("led")])
self.modified = modified_meta.create_attribute_model()
yield "modified", self.modified, None
class TestTableMetaValidation(unittest.TestCase):
def setUp(self):
self.tm = TableMeta("desc")
self.tm.set_elements(dict(c1=StringArrayMeta()))
def test_validate_from_good_table(self):
tm = self.tm
t = Table(tm)
t.c1 = ["me", "me3"]
t_serialized = t.to_dict()
t = tm.validate(t)
assert t.to_dict() == t_serialized
def test_validate_from_serialized(self):
tm = self.tm
serialized = dict(typeid="anything", c1=("me", "me3"))
t = tm.validate(serialized)
assert t.endpoints == ["c1"]
assert t.c1 == serialized["c1"]
def _make_table(self, field_name, field_data):
group_tag = self._make_group("parameters")
tags = [widget("table"), group_tag, config()]
meta = TableMeta(field_data.description, tags)
part = PandABlocksTablePart(self.client,
meta,
self.block_name,
field_name,
writeable=True)
self._add_part(field_name, part)
def setUp(self):
self.client = Mock()
fields = OrderedDict()
fields["NREPEATS"] = (7, 0)
fields["INPUT_MASK"] = (32, 32)
fields["TRIGGER_MASK"] = (48, 48)
fields["TIME_PH_A"] = (95, 64)
self.client.get_table_fields.return_value = fields
self.meta = TableMeta("Seq table")
self.o = PandABlocksTablePart(self.client,
self.meta,
block_name="SEQ1",
field_name="TABLE",
writeable=True)
from malcolm.modules.builtin.vmetas import StringArrayMeta, ChoiceArrayMeta, \
TableMeta, NumberArrayMeta, StringMeta
from malcolm.modules.scanning.controllers import RunnableController
from malcolm.tags import widget
# Make a table for the dataset info we produce
columns = OrderedDict()
columns["name"] = StringArrayMeta("Dataset name")
columns["filename"] = StringArrayMeta(
"Filename of HDF file relative to fileDir")
columns["type"] = ChoiceArrayMeta("Type of dataset", dataset_types)
columns["rank"] = NumberArrayMeta("int32", "Rank (number of dimensions)")
columns["path"] = StringArrayMeta("Dataset path within HDF file")
columns["uniqueid"] = StringArrayMeta("UniqueID array path within HDF file")
dataset_table_meta = TableMeta("Datsets produced in HDF file",
elements=columns,
tags=[widget("table")])
@method_takes("name", StringMeta("Name of the Part within the controller"),
REQUIRED)
class DatasetTablePart(Part):
"""Exposes an Attribute that reports the datasets that will be written
during a scan"""
def __init__(self, params):
# Created attributes
self.datasets = None
super(DatasetTablePart, self).__init__(params.name)
def create_attribute_models(self):
# Create read-only attribute showing the datasets we are creating
def setUp(self):
self.tm = TableMeta("desc")
self.tm.set_elements(dict(c1=StringArrayMeta()))
def test_to_dict(self):
tm = TableMeta("desc")
tm.set_label("Name")
tm.set_elements(dict(c1=self.sam))
tm.set_writeable(True)
assert tm.to_dict() == self.serialized
def setUp(self):
tm = TableMeta("desc")
tm.process = Mock()
self.tm = tm