def update_configure_model(
configure_model: MethodMeta,
part_configure_infos: List[ConfigureParamsInfo]) -> None:
# These will not be inserted as they already exist
ignored = list(ConfigureHook.call_types)
# Re-calculate the following
required = []
metas = OrderedDict()
defaults = OrderedDict()
# First do the required arguments
for k in configure_model.takes.required:
required.append(k)
metas[k] = configure_model.takes.elements[k]
for info in part_configure_infos:
for k in info.required:
if k not in required + ignored:
required.append(k)
# TODO: moan about type changes, when != works...
metas[k] = info.metas[k]
# Now the default and optional
for k in configure_model.takes.elements:
if k not in required:
metas[k] = configure_model.takes.elements[k]
for info in part_configure_infos:
for k, meta in info.metas.items():
if k not in required + ignored:
# TODO: moan about type changes, when != works...
metas[k] = meta
if k in info.defaults:
if isinstance(meta, TableMeta) and not min(
m.writeable for m in meta.elements.values()):
# This is a table with non-writeable rows, merge the
# defaults together row by row
rows = []
if k in defaults:
rows += defaults[k].rows()
rows += info.defaults[k].rows()
assert meta.table_cls, "No Meta table class"
defaults[k] = meta.table_cls.from_rows(rows)
else:
defaults[k] = info.defaults[k]
# Copy and prepare values for takes and returns
takes_metas = OrderedDict()
returns_metas = OrderedDict()
for k, v in metas.items():
takes_metas[k] = deserialize_object(v.to_dict(), VMeta)
returns_metas[k] = deserialize_object(v.to_dict(), VMeta)
returns_metas[k].set_writeable(False)
# Set them on the model
configure_model.takes.set_elements(takes_metas)
configure_model.takes.set_required(required)
configure_model.returns.set_elements(returns_metas)
configure_model.returns.set_required(required)
configure_model.set_defaults(defaults)
def test_from_dict(self):
m = MethodMeta.from_dict(self.serialized)
assert m.takes.to_dict() == self.takes.to_dict()
assert m.defaults == self.serialized["defaults"]
assert m.tags == []
assert m.writeable is False
assert m.label == ""
assert m.returns.to_dict() == MapMeta().to_dict()
def update_configure_params(
self, part: Part = None, info: ConfigureParamsInfo = None
) -> None:
"""Tell controller part needs different things passed to Configure"""
with self.changes_squashed:
# Update the dict
if part:
assert info, "No info for part"
self.part_configure_params[part] = info
# No process yet, so don't do this yet
if self.process is None:
return
# Make a list of all the infos that the parts have contributed
part_configure_infos = []
for part in self.parts.values():
info = self.part_configure_params.get(part, None)
if info:
part_configure_infos.append(info)
# Update methods from the updated configure model
for method_name in ("configure", "validate"):
# Get the model of our configure method as the starting point
method_meta = MethodMeta.from_callable(self.configure)
# Update the configure model from the infos
update_configure_model(method_meta, part_configure_infos)
# Put the created metas onto our block meta
method = self._block[method_name]
method.meta.takes.set_elements(method_meta.takes.elements)
method.meta.takes.set_required(method_meta.takes.required)
method.meta.returns.set_elements(method_meta.returns.elements)
method.meta.returns.set_required(method_meta.returns.required)
method.meta.set_defaults(method_meta.defaults)
method.set_took()
method.set_returned()
def test_to_dict(self):
m = MethodMeta(description="test_description")
m.set_takes(self.takes)
m.set_defaults(self.serialized["defaults"])
assert m.to_dict() == self.serialized
def test_set_label(self):
m = MethodMeta(description="test_description")
m.set_label("new_label")
assert "new_label" == m.label
def test_init(self):
m = MethodMeta(description="test_description")
assert "test_description" == m.description
assert "malcolm:core/MethodMeta:1.1" == m.typeid
assert "" == m.label