Sets free one or more parameters which have been linked previously

        :param parameter: the parameter to be set free, can also be a list of parameters
        :return: (none)
160263
def unlink(self, parameter):
        

        if not isinstance(parameter,list):
        # Make a list of one element
            parameter_list  = [parameter]
        else:
        # Make a copy to avoid tampering with the input
            parameter_list = list(parameter)
            
        for param in parameter_list:    
            if param.has_auxiliary_variable():
                param.remove_auxiliary_variable()

            else:

                with warnings.catch_warnings():

                    warnings.simplefilter("always", RuntimeWarning)

                    warnings.warn("Parameter %s has no link to be removed." % param.path, RuntimeWarning)
1119510
def __set_parameters(self):
        
        self.__set_buffer_start(self.CMD_SET_PARAMETERS)
        # Can I send 0xFF as address to not change it each time?
        # Worry about writing to EEPROM or Flash with each address change.
        # Would then implement a separate address only change function.
        self.STRUCT_SET_PARAMETERS.pack_into(self.__out_buffer, self.OFFSET_PAYLOAD,
                                             self._max_current, self._max_power, self.address,
                                             self._load_mode, self._load_value)
        self.__set_checksum()
        self.__send_buffer()
        self.update_status()
1026843
def param_remove(self, param: 'str') -> None:
        
        for attr in self._param_attr_dicts:
            if param in self.__dict__[attr]:
                self.__dict__[attr].pop(param)

        for attr in self._param_attr_lists:
            if param in self.__dict__[attr]:
                self.__dict__[attr].remove(param)
1078830
def isSet(self, param):
        
        param = self._resolveParam(param)
        return param in self._paramMap
421131
def set_params(self,**kwargs):
        
        for key,value in list(kwargs.items()):
            setattr(self,key,value)
715456
def from_parameter(cls: Type[UnlockParameterType], parameter: str) -> Optional[Union[SIGParameter, XHXParameter]]:
        

        sig_param = SIGParameter.from_parameter(parameter)
        if sig_param:
            return sig_param
        else:
            xhx_param = XHXParameter.from_parameter(parameter)
            if xhx_param:
                return xhx_param

        return None
1016578
def add_external_parameter(self, parameter):
        

        assert isinstance(parameter, Parameter), "Variable must be an instance of IndependentVariable"

        if self._has_child(parameter.name):

            # Remove it from the children only if it is a Parameter instance, otherwise don't, which will
            # make the _add_child call fail (which is the expected behaviour! You shouldn't call two children
            # with the same name)

            if isinstance(self._get_child(parameter.name), Parameter):

                warnings.warn("External parameter %s already exist in the model. Overwriting it..." % parameter.name,
                              RuntimeWarning)

                self._remove_child(parameter.name)

        # This will fail if another node with the same name is already in the model

        self._add_child(parameter)
401565
def _set_parameters(self, parameters):
        """"""
        for theta in self.variables['theta']:
            val = 1.0
            # TODO: improve approach for initializing parameters.
            if parameters is not None:
                if theta.name in parameters:
                    val = parameters[theta.name]
            # Add parameter.
            
            self.link_parameters(Param(theta.name, val, None))
438151
def get_parameter(self, name):
        
        for parameter in self._parameters:
            if parameter.name == name:
                return parameter
1282032
def drop_param(_param, _method, *args, **kwargs):
    
    assert callable(_method), "method %r is not callable" % (_method, )
    return _method(*args, **kwargs)
1135856
def set_args(self, arguments):
        
        return lib.zproc_set_args(self._as_parameter_, byref(zlist_p.from_param(arguments)))
1074331
def set_params(self, **params):
        
        clone = copy.deepcopy(self)
        clone.adapter.set_params(**params)
        return clone
1156830
public HttpRequest withoutParameter(String parameter) {
		if(Strings.isValid(parameter)) {
			for(HttpParameter p : parameters) {
				if(parameter.equals(p.getName())) {
					parameters.remove(p);
				}
			}
		}
		return this;
	}
462663
def set_parameters(self,parameters):
        
        
        for key,value in list(parameters.items()):
            if key in self.parameters:
                self.parameters[key] = value
539268
public static void empty(String parameter, String name) {
		if (parameter == null || !parameter.isEmpty()) {
			throw new IllegalArgumentException(name + " is null or not empty.");
		}
	}
1161109
def _set_stream_parameters(self, **kwargs):
        
        with util.disable_constant(self):
            self.param.set_param(**kwargs)
47938
def set_parameter(self, key, value):
        
        for x in self.transformed_structures:
            x.other_parameters[key] = value