def setUp(self):
meta = Mock()
meta.elements = OrderedDict()
meta.elements["e1"] = StringArrayMeta()
meta.elements["e2"] = NumberArrayMeta("int32")
meta.elements["e3"] = NumberArrayMeta("int32")
self.meta = meta
def test_int_against_int(self):
nm = NumberArrayMeta("int32")
values = [1, 2, 3]
response = nm.validate(values)
for i, value in enumerate(response):
assert values[i] == value
def test_numpy_array(self):
nm = NumberArrayMeta("float64")
values = np.array([1.2, 3.4, 5.6])
response = nm.validate(values)
for i, value in enumerate(response):
assert values[i] == value
def test_float_against_float32(self):
nm = NumberArrayMeta("float32")
values = [1.2, 3.4, 5.6]
response = nm.validate(values)
for i, value in enumerate(response):
self.assertAlmostEqual(values[i], response[i], places=5)
def test_float_against_float64(self):
nm = NumberArrayMeta("float64")
values = [1.2, 3.4, 5.6]
response = nm.validate(values)
for i, value in enumerate(response):
assert values[i] == value
def setUp(self):
meta = Mock()
meta.elements = OrderedDict()
meta.elements["e1"] = NumberArrayMeta("int32")
meta.elements["e2"] = NumberArrayMeta("int32")
meta.elements["e3"] = NumberArrayMeta("int32")
self.t = Table(meta)
self.t.e1 = [1]
self.t.e2 = [2]
self.t.e3 = [3]
def __init__(self, client, meta, block_name, field_name, writeable):
super(PandABlocksTablePart, self).__init__(client, meta, block_name,
field_name, writeable)
# Fill in the meta object with the correct headers
columns = OrderedDict()
self.fields = OrderedDict()
fields = client.get_table_fields(block_name, field_name)
for field_name, (bits_hi, bits_lo) in fields.items():
nbits = bits_hi - bits_lo + 1
if nbits < 1:
raise ValueError("Bad bits %s:%s" % (bits_hi, bits_lo))
if nbits == 1:
column_meta = BooleanArrayMeta(field_name)
widget_tag = widget("checkbox")
else:
if nbits <= 8:
dtype = "uint8"
elif nbits <= 16:
dtype = "uint16"
elif nbits <= 32:
dtype = "uint32"
elif nbits <= 64:
dtype = "uint64"
else:
raise ValueError("Bad bits %s:%s" % (bits_hi, bits_lo))
column_meta = NumberArrayMeta(dtype, field_name)
widget_tag = widget("textinput")
column_name = snake_to_camel(field_name)
column_meta.set_label(camel_to_title(column_name))
column_meta.set_tags([widget_tag])
columns[column_name] = column_meta
self.fields[column_name] = (bits_hi, bits_lo)
meta.set_elements(columns)
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
def test_init_with_dict(self):
meta = Mock()
meta.elements = {
"e1": NumberArrayMeta("int32"),
"e2": StringArrayMeta(),
"e3": StringArrayMeta()
}
d = {"e1": [0, 1], "e3": ["value"]}
t = Table(meta, d)
assert [0, 1] == list(t.e1)
assert () == t.e2
assert ("value", ) == t.e3
assert "malcolm:core/Table:1.0" == t.typeid
from malcolm.compat import OrderedDict
from malcolm.core import Part, Table, method_takes, REQUIRED
from malcolm.modules.ADCore.infos import DatasetProducedInfo, dataset_types
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 test_none_validates(self):
nm = NumberArrayMeta("int32")
assert list(nm.validate(None)) == []
def test_null_element_zero(self):
nm = NumberArrayMeta("float64")
actual = nm.validate([1.2, None, 1.3])
assert actual[0] == 1.2
assert np.isnan(actual[1])
assert actual[2] == 1.3
def test_float_against_int_floors(self):
nm = NumberArrayMeta("int32")
actual = list(nm.validate([1.2, 34, 56]))
expected = [1, 34, 56]
assert actual == expected
def test_numpy_array_wrong_number_type_raises(self):
nm = NumberArrayMeta("int32")
values = np.array([1.2, 3.4, 5.6])
with self.assertRaises(TypeError):
nm.validate(values)
def test_numpy_array_wrong_type_raises(self):
nm = NumberArrayMeta("float64")
values = "[1.2, 3.4, 5.6]"
with self.assertRaises(TypeError):
nm.validate(values)
def create_meta(self, description, tags):
return NumberArrayMeta("int32", description=description, tags=tags)