Set or reset the internal param list from the dict's contents.
514045
def syncParamList(self, firstTime, preserve_order=True):
        
        # See the note in setParam about this design.

        # Get latest par values from dict.  Make sure we do not
        # change the id of the __paramList pointer here.
        new_list = self._getParamsFromConfigDict(self, initialPass=firstTime)
                                               # dumpCfgspcTo=sys.stdout)
        # Have to add this odd last one for the sake of the GUI (still?)
        if self._forUseWithEpar:
            new_list.append(basicpar.IrafParS(['$nargs','s','h','N']))

        if len(self.__paramList) > 0 and preserve_order:
            # Here we have the most up-to-date data from the actual data
            # model, the ConfigObj dict, and we need to use it to fill in
            # our param list.  BUT, we need to preserve the order our list
            # has had up until now (by unique parameter name).
            namesInOrder = [p.fullName() for p in self.__paramList]
            assert len(namesInOrder) == len(new_list), \
                   'Mismatch in num pars, had: '+str(len(namesInOrder))+ \
                   ', now we have: '+str(len(new_list))+', '+ \
                   str([p.fullName() for p in new_list])
            self.__paramList[:] = [] # clear list, keep same pointer
            # create a flat dict view of new_list, for ease of use in next step
            new_list_dict = {} # can do in one step in v2.7
            for par in new_list: new_list_dict[par.fullName()] = par
            # populate
            for fn in namesInOrder:
                self.__paramList.append(new_list_dict[fn])
        else:
            # Here we just take the data in whatever order it came.
            self.__paramList[:] = new_list
263003
def reset(self, data={}):
        
        if data and (isinstance(data, dict) or isinstance(data, list)):
            self._json_data = data
        else:
            self._json_data = copy.deepcopy(self._raw_data)

        self.__reset_queries()
        return self
1356871
def param_list_to_dict(list,param_struct,skeys):
    
    RV = []
    i0= 0
    for key in skeys:
        val = param_struct[key]
        shape = SP.array(val)
        np = shape.prod()
        i1 = i0+np
        params = list[i0:i1].reshape(shape)
        RV.append((key,params))
        i0 = i1
    return dict(RV)
81809
def _imm_init_setattr(self, name, value):
    '''
    
    '''
    params = _imm_param_data(self)
    if name in params:
        tx_fn = params[name][1]
        value = value if tx_fn is None else tx_fn(value)
        # Set the value
        object.__getattribute__(self, '__dict__')[name] = value
        # No checks are run, as we're in initialization mode...
    else:
        raise TypeError(
            'Attempt to change non-parameter \'%s\' of initializing immutable' % name)
855520
def setParams(self, inputCol=None, outputCol=None, stopWords=None, caseSensitive=False,
                  locale=None):
        
        kwargs = self._input_kwargs
        return self._set(**kwargs)
768982
public static Dictionary<String, String> convertInitParams(
			final WebAppInitParam[] initParams) {
		if (initParams == null || initParams.length == 0) {
			return null;
		}
		Hashtable<String, String> dictionary = new Hashtable<>();
		for (WebAppInitParam initParam : initParams) {
			dictionary.put(initParam.getParamName(), initParam.getParamValue());
		}
		return dictionary;
	}
303211
def reset(self):
        
        for name in self.__dict__:
            if name.startswith("_"):
                continue

            attr = getattr(self, name)
            setattr(self, name, attr and attr.__class__())
80892
def _copyValues(self, to, extra=None):
        
        paramMap = self._paramMap.copy()
        if extra is not None:
            paramMap.update(extra)
        for param in self.params:
            # copy default params
            if param in self._defaultParamMap and to.hasParam(param.name):
                to._defaultParamMap[to.getParam(param.name)] = self._defaultParamMap[param]
            # copy explicitly set params
            if param in paramMap and to.hasParam(param.name):
                to._set(**{param.name: paramMap[param]})
        return to
751856
def set_defaults(self, default_config_params):
        
        map = StringValueMap.from_maps(default_config_params, self)
        return ConfigParams(map)
1220376
def param_dict_to_list(dict,skeys=None):
    """"""
    #sort keys
    RV = SP.concatenate([dict[key].flatten() for key in skeys])
    return RV
    pass
1138273
def update(self, params, ignore_set=False, overwrite=False):
        
        log = logging.getLogger(__name__)
        valid = {i[0] for i in self}
        for key, value in params.items():
            if not hasattr(self, key):
                raise AttributeError("'{}' object has no attribute '{}'".format(self.__class__.__name__, key))
            if key not in valid:
                message = "'{}' object does not support item assignment on '{}'"
                raise AttributeError(message.format(self.__class__.__name__, key))
            if key in self._already_set:
                if ignore_set:
                    log.debug('%s already set in config, skipping.', key)
                    continue
                if not overwrite:
                    message = "'{}' object does not support item re-assignment on '{}'"
                    raise AttributeError(message.format(self.__class__.__name__, key))
            setattr(self, key, value)
            self._already_set.add(key)
1058292
def set_parameters(self):
        
        for key in (ADMITTED_STR_PARAMETERS + ADMITTED_FLOAT_PARAMETERS +
                    ADMITTED_SET_PARAMETERS):
            try:
                val = getattr(self.gmpe, key)
            except AttributeError:
                pass
            else:
                setattr(self, key, val)
161416
def reset(self):
        
        with util.disable_constant(self):
            for k, p in self.params().items():
                if k != 'name':
                    setattr(self, k, p.default)
1192776
def set_param(self, into, name):
        
        value, complex = self.getlist(name)
        if value is not None:
            into[name] = value
        return complex
848997
def update_params(self, param_d):
        
        for param in self.paramlst:
            if param.name in param_d:
                value = param_d[param.name]
                setattr(self.obj, param.name, value)
238493
def fix_parameters(self):
        """"""
        for W, b in zip(self.W_list, self.b_list):
            W.fix()
            b.fix()
583598
def set_params(self, **params):
        
        if self._solr_locked:
            raise Exception("Query already executed, no changes can be made."
                            "%s %s" % (self._solr_query, self._solr_params)
                            )
        self._solr_params.update(params)