docs: def update_configure_params(self, part=None, info=None):
          # type: (Part, ConfigureParamsInfo) -> None
          """Tell controller part needs different things passed to Configure"""
          with self.changes_squashed:
              # Update the dict
              if part:
                  self.part_configure_params[part] = info
  
              # No process yet, so don't do this yet
              if self.process is None:
                  return
  
              # Get the model of our configure method as the starting point
              configure_model = MethodModel.from_callable(self.configure)
  
              # These will not be inserted as the already exist
              ignored = tuple(ConfigureHook.call_types)
  
              # Re-calculate the following
              required = []
              takes_elements = OrderedDict()
              defaults = OrderedDict()
  
              # First do the required arguments
              for k in configure_model.takes.required:
                  required.append(k)
                  takes_elements[k] = configure_model.takes.elements[k]
              for part in self.parts.values():
                  try:
                      info = self.part_configure_params[part]
                  except KeyError:
                      continue
                  for k in info.required:
                      if k not in required and k not in ignored:
                          required.append(k)
                          takes_elements[k] = info.metas[k]
  
              # Now the default and optional
              for k in configure_model.takes.elements:
                  if k not in required:
                      takes_elements[k] = configure_model.takes.elements[k]
              for part in self.parts.values():
                  try:
                      info = self.part_configure_params[part]
                  except KeyError:
                      continue
                  for k in info.metas:
                      if k not in required and k not in ignored:
                          takes_elements[k] = info.metas[k]
                          if k in info.defaults:
                              defaults[k] = info.defaults[k]
  
              # Set the values
              configure_model.takes.set_elements(takes_elements)
              configure_model.takes.set_required(required)
              configure_model.set_defaults(defaults)
  
              # Update methods from the new metas
              self._block.configure.set_takes(configure_model.takes)
              self._block.configure.set_defaults(configure_model.defaults)
  
              # Now make a validate model with returns
              validate_model = MethodModel.from_dict(configure_model.to_dict())
              returns = MapMeta.from_dict(validate_model.takes.to_dict())
              for v in returns.elements.values():
                  v.set_writeable(False)
              self._block.validate.set_takes(validate_model.takes)
              self._block.validate.set_defaults(validate_model.defaults)
              self._block.validate.set_returns(returns)