<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 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)