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