:param param: param object to remove from being a parameter of this parameterized object.
970631
def unlink_parameter(self, param):
        
        if not param in self.parameters:
            try:
                raise HierarchyError("{} does not belong to this object {}, remove parameters directly from their respective parents".format(param._short(), self.name))
            except AttributeError:
                raise HierarchyError("{} does not seem to be a parameter, remove parameters directly from their respective parents".format(str(param)))

        start = sum([p.size for p in self.parameters[:param._parent_index_]])
        self.size -= param.size
        del self.parameters[param._parent_index_]
        self._remove_parameter_name(param)


        param._disconnect_parent()
        param.remove_observer(self, self._pass_through_notify_observers)
        for name, iop in self._index_operations.items():
            iop.shift_left(start, param.size)

        self._connect_parameters()
        self._notify_parent_change()

        parent = self._parent_
        while parent is not None:
            parent.size -= param.size
            parent = parent._parent_

        self._highest_parent_._connect_parameters()
        self._highest_parent_._connect_fixes()
        self._highest_parent_._notify_parent_change()
239781
def parameter(self, parser):
        
        return (Suppress(self.syntax.params_start).leaveWhitespace() +
                Group(parser) + Suppress(self.syntax.params_stop))
726179
public void removeParameter( String name )
    {
        if (_parameters == null || !_parameters.hasParameters())
            return;

        _parameters.removeParameter(name);
    }
978502
def insert_param(self, param):
        
        self._current_params = tuple([param] + list(self._current_params))
31777
def set(self, param, value):
        
        self._shouldOwn(param)
        try:
            value = param.typeConverter(value)
        except ValueError as e:
            raise ValueError('Invalid param value given for param "%s". %s' % (param.name, e))
        self._paramMap[param] = value
156849
public void removeParameter(ParamType type) {

        switch (type) {
            case language:
                m_localeSelection.reset();
                break;
            case text:
                m_searchInput.setFormValueAsString("");
                break;
            case expired:
                m_includeExpiredCheckBox.setChecked(false);
                break;
            case creation:
                m_dateCreatedStartDateBox.setValue(null, true);
                m_dateCreatedEndDateBox.setValue(null, true);
                break;
            case modification:
                m_dateModifiedStartDateBox.setValue(null, true);
                m_dateModifiedEndDateBox.setValue(null, true);
                break;
            case scope:
                m_scopeSelection.setFormValueAsString(m_defaultScope.name());
                break;
            default:
        }
    }
1345557
def __non_body_parameter_descriptor(self, param):
    
    descriptor = {}

    descriptor['name'] = param.name

    param_type, param_format = self.__field_to_parameter_type_and_format(param)

    # Required
    if param.required:
      descriptor['required'] = True

    # Type
    descriptor['type'] = param_type

    # Format (optional)
    if param_format:
      descriptor['format'] = param_format

    # Default
    default = self.__parameter_default(param)
    if default is not None:
      descriptor['default'] = default

    # Repeated
    if param.repeated:
      descriptor['repeated'] = True

    # Enum
    enum_descriptor = self.__parameter_enum(param)
    if enum_descriptor is not None:
      descriptor['enum'] = enum_descriptor

    return descriptor
820510
def pop_parameter(key):
    '''

    '''
    names = key.split('/')
    if len(names) > 1:
        with parameter_scope(names[0]):
            return pop_parameter('/'.join(names[1:]))
    global current_scope
    param = current_scope.get(key, None)
    if param is not None:
        del current_scope[key]
    return param
979044
def p_param(self, p):
        ''
        paramlist = [Parameter(rname, rvalue, lineno=p.lineno(2))
                     for rname, rvalue in p[2]]
        p[0] = Decl(tuple(paramlist), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
666108
def remove(self, parameters):
        

        # Verify that we already know our assigned subscription_id
        assert self.subscription_id != -1

        if not parameters:
            return

        options = web_pb2.ParameterSubscriptionRequest()
        options.subscriptionId = self.subscription_id
        options.id.extend(_build_named_object_ids(parameters))

        self._manager.send('unsubscribe', options)
264723
def params(self_, parameter_name=None):
        
        if self_.self is not None and self_.self._instance__params:
            self_.warning('The Parameterized instance has instance '
                          'parameters created using new-style param '
                          'APIs, which are incompatible with .params. '
                          'Use the new more explicit APIs on the '
                          '.param accessor to query parameter instances.'
                          'To query all parameter instances use '
                          '.param.objects with the option to return '
                          'either class or instance parameter objects. '
                          'Alternatively use .param[name] indexing to '
                          'access a specific parameter object by name.')

        pdict = self_.objects(instance='existing')
        if parameter_name is None:
            return pdict
        else:
            return pdict[parameter_name]
737130
def remove_query_param(url, key):
    

    (scheme, netloc, path, query, fragment) = urlparse.urlsplit(url)
    query_dict = urlparse.parse_qs(query)
    query_dict.pop(key, None)
    query = urlparse.urlencode(sorted(list(query_dict.items())), doseq=True)
    return urlparse.urlunsplit((scheme, netloc, path, query, fragment))
399317
public function remove($param)
        {
            if ($param instanceof Container) {
                $param = $param->id;
            }

            $item = $this->get($param);

            if ($item) {
                $id = (int) $item->id;

                if ($this->_items[$id]) {
                    unset($this->_items[$id]);
                }
            }

            return $this;
        }
1144890
def __pop_params(self, tid):
        
        stack = self.__paramStack[tid]
        stack.pop()
        if not stack:
            del self.__paramStack[tid]
278312
def rm_parameter(self, name):
        
        if name not in self._parameters:
            raise ValueError("no '%s' parameter found" % (name))

        del self._parameters[name]
        del self.__dict__[name]
999072
def parameter(self, name=None, value=None, **kwargs):
        
        return self.nest(Parameter(name=name, value=value, **kwargs))
880403
def set_default(self_,param_name,value):
        
        cls = self_.cls
        setattr(cls,param_name,value)