def test_to_dict(self):
columns = OrderedDict()
columns["foo"] = StringArrayMeta(label="Foo")
columns["bar"] = StringArrayMeta()
meta = TableMeta(description="desc", tags=[], writeable=True,
label="my label", columns=columns)
value = Table(meta)
value.foo = ["foo1", "foo2"]
value.bar = ["bar1", "bar2"]
o = meta.make_attribute(value)
self.assertEqual(o.to_dict(), self.serialized)
def test_to_dict(self):
columns = OrderedDict()
columns["foo"] = StringArrayMeta(label="Foo")
columns["bar"] = StringArrayMeta()
meta = TableMeta(description="desc",
tags=[],
writeable=True,
label="my label",
columns=columns)
value = Table(meta)
value.foo = ["foo1", "foo2"]
value.bar = ["bar1", "bar2"]
o = meta.make_attribute(value)
self.assertEqual(o.to_dict(), self.serialized)
def make_return_table(self, part_tasks):
# Filter part tasks so that we only run the ones hooked to us
columns = OrderedDict(name=StringArrayMeta("Part name"))
for part in part_tasks:
hooked = [
method_name
for (method_name, hook, _) in get_hook_decorated(part)
if hook is self
]
for method_name, method_meta, func in get_method_decorated(part):
if method_name in hooked:
# Add return metas to the table columns
for arg_name in method_meta.returns.elements:
md = method_meta.returns.elements[arg_name].to_dict()
if "ArrayMeta" in md["typeid"]:
md["tags"] = md["tags"] + ["hook:return_array"]
else:
md["typeid"] = md["typeid"].replace(
"Meta", "ArrayMeta")
meta = deserialize_object(md, VArrayMeta)
if arg_name in columns:
column_d = columns[arg_name].to_dict()
assert column_d == md, \
"%s != %s" % (column_d, md)
columns[arg_name] = meta
meta = TableMeta("Part returns from hook", columns=columns)
return_table = Table(meta)
return return_table
def test_init(self):
tm = TableMeta("desc")
self.assertEquals("desc", tm.description)
self.assertEquals("malcolm:core/TableMeta:1.0", tm.typeid)
self.assertEquals((), tm.tags)
self.assertEquals(False, tm.writeable)
self.assertEquals("", tm.label)
def test_from_dict(self):
tm = TableMeta.from_dict(self.serialized)
self.assertEquals(tm.description, "desc")
self.assertEquals(len(tm.elements), 1)
self.assertEquals(tm.elements["c1"].to_dict(), self.sam.to_dict())
self.assertEquals(tm.tags, ())
self.assertEquals(tm.writeable, True)
self.assertEquals(tm.label, "Name")
def test_from_dict(self):
tm = TableMeta.from_dict(self.serialized)
self.assertEquals(tm.description, "desc")
self.assertEquals(len(tm.elements), 1)
self.assertEquals(tm.elements["c1"].to_dict(), self.sam.to_dict())
self.assertEquals(tm.tags, [])
self.assertEquals(tm.writeable, True)
self.assertEquals(tm.label, "Name")
def create_attributes(self):
for data in super(ManagerController, self).create_attributes():
yield data
# Make a table for the layout info we need
columns = OrderedDict()
columns["name"] = StringArrayMeta("Name of layout part")
columns["mri"] = StringArrayMeta("Malcolm full name of child block")
columns["x"] = NumberArrayMeta("float64", "X Coordinate of child block")
columns["y"] = NumberArrayMeta("float64", "Y Coordinate of child block")
columns["visible"] = BooleanArrayMeta("Whether child block is visible")
layout_table_meta = TableMeta("Layout of child blocks", columns=columns)
layout_table_meta.set_writeable_in(sm.EDITABLE)
self.layout = layout_table_meta.make_attribute()
yield "layout", self.layout, self.set_layout
self.layout_name = StringMeta(
"Saved layout name to load").make_attribute()
self.layout_name.meta.set_writeable_in(sm.EDITABLE)
yield "layoutName", self.layout_name, self.load_layout
class TestTableMetaValidation(unittest.TestCase):
def setUp(self):
self.tm = TableMeta("desc")
self.tm.set_elements(TableElementMap(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)
self.assertEqual(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)
self.assertEqual(t.endpoints, ["c1"])
self.assertEqual(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 = PandABoxTablePart(self.process,
self.control,
meta,
self.block_name,
field_name,
writeable=True)
self._add_part(field_name, part)
def create_attributes(self):
for data in super(ManagerController, self).create_attributes():
yield data
# Make a table for the layout info we need
columns = OrderedDict()
columns["name"] = StringArrayMeta("Name of layout part")
columns["mri"] = StringArrayMeta("Malcolm full name of child block")
columns["x"] = NumberArrayMeta("float64", "X Coordinate of child block")
columns["y"] = NumberArrayMeta("float64", "Y Coordinate of child block")
columns["visible"] = BooleanArrayMeta("Whether child block is visible")
layout_table_meta = TableMeta("Layout of child blocks", columns=columns)
layout_table_meta.set_writeable_in(sm.EDITABLE)
self.layout = layout_table_meta.make_attribute()
yield "layout", self.layout, self.set_layout
self.layout_name = ChoiceMeta(
"Saved layout name to load", []).make_attribute()
self.layout_name.meta.set_writeable_in(
self.stateMachine.AFTER_RESETTING)
yield "layoutName", self.layout_name, self.load_layout
assert os.path.isdir(self.params.configDir), \
"%s is not a directory" % self.params.configDir
class TestTableMetaValidation(unittest.TestCase):
def setUp(self):
self.tm = TableMeta("desc")
self.tm.set_elements(TableElementMap(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)
self.assertEqual(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)
self.assertEqual(t.endpoints, ["c1"])
self.assertEqual(t.c1, serialized["c1"])
def setUp(self):
self.process = Mock()
self.control = Mock()
fields = OrderedDict()
fields["NREPEATS"] = (7, 0)
fields["INPUT_MASK"] = (32, 32)
fields["TRIGGER_MASK"] = (48, 48)
fields["TIME_PH_A"] = (95, 64)
self.control.get_table_fields.return_value = fields
self.meta = TableMeta("Seq table")
self.o = PandABoxTablePart(self.process,
self.control,
self.meta,
block_name="SEQ1",
field_name="TABLE",
writeable=True)
configure_args = [
"generator",
PointGeneratorMeta("Generator instance"), REQUIRED, "axes_to_move",
StringArrayMeta("Axes that should be moved"), REQUIRED, "exposure",
NumberMeta("float64", "How long to remain at each point"), REQUIRED
]
# Make a table for the layout info we need
columns = OrderedDict()
columns["name"] = StringArrayMeta("Name of layout part")
columns["mri"] = StringArrayMeta("Malcolm full name of child block")
columns["x"] = NumberArrayMeta("float64", "X Co-ordinate of child block")
columns["y"] = NumberArrayMeta("float64", "X Co-ordinate of child block")
columns["visible"] = BooleanArrayMeta("Whether child block is visible")
layout_table_meta = TableMeta("Layout of child blocks", columns=columns)
# Make a table for the port info we need
columns = OrderedDict()
columns["name"] = StringArrayMeta("Name of layout part")
columns["type"] = StringArrayMeta("Type of outport (e.g. bit or pos)")
columns["value"] = StringArrayMeta("Value of outport (e.g. PULSE1.OUT)")
outport_table_meta = TableMeta("List of ports on blocks", columns=columns)
@sm.insert
@method_takes()
class ManagerController(DefaultController):
"""RunnableDevice implementer that also exposes GUI for child parts"""
# hooks
Report = Hook()
def test_to_dict(self):
tm = TableMeta("desc")
tm.set_label("Name")
tm.set_elements(TableElementMap(dict(c1=self.sam)))
tm.set_writeable(True)
self.assertEqual(tm.to_dict(), self.serialized)
def setUp(self):
self.tm = TableMeta("desc")
self.tm.set_elements(TableElementMap(dict(c1=StringArrayMeta())))
def setUp(self):
self.tm = TableMeta("desc")
self.tm.set_elements(TableElementMap(dict(c1=StringArrayMeta())))
def test_to_dict(self):
tm = TableMeta("desc")
tm.set_label("Name")
tm.set_elements(TableElementMap(dict(c1=self.sam)))
tm.set_writeable(True)
self.assertEqual(tm.to_dict(), self.serialized)
def setUp(self):
tm = TableMeta("desc")
tm.process = Mock()
self.tm = tm
def setUp(self):
tm = TableMeta("desc")
tm.report_changes = Mock(wrap=tm.report_changes)
self.tm = tm
from malcolm.core.vmetas import StringArrayMeta, ChoiceArrayMeta, TableMeta, \
NumberArrayMeta
from malcolm.controllers.runnablecontroller import RunnableController
# Make a table for the dataset info we produce
dataset_types = [
"primary", "secondary", "monitor", "position_set", "position_value"]
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", columns=columns)
# Produced by plugins in part_info
class DatasetProducedInfo(Info):
def __init__(self, name, filename, type, rank, path, uniqueid):
self.name = name
self.filename = filename
assert type in dataset_types, \
"Dataset type %s not in %s" % (type, dataset_types)
self.type = type
self.rank = rank
self.path = path
self.uniqueid = uniqueid
def setUp(self):
tm = TableMeta("desc")
tm.process = Mock()
self.tm = tm
