Adds a new item from the given (key, value)-tuple.
            If the key exists, pushes the updated item to the head of the dict.
14318
def push(self, kv):
        
        if kv[0] in self: 
            self.__delitem__(kv[0])
        self.__setitem__(kv[0], kv[1])
1180946
def kadd(self, key, value):
        
        for item in self:
            try:
                # Use the key as a set
                item[key].add(value)
            except KeyError:
                # This happens if the key is not present
                item[key] = value
            except AttributeError:
                # This happens if the key is present but is not a set
                item[key] = set([item[key], value])
675047
def update(self, key, value):
        
        if not isinstance(value, dict):
            raise BadValueError(
                'The value {} is incorrect.'
                ' Values should be strings'.format(value))
        if key in self.data:
            v = self.get(key)
            v.update(value)
        else:
            v = value
        self.set(key, v)
506856
def push(tuple)
      key = bin_key(tuple)
      @hash[key] ||= TupleBin.new
      @hash[key].add(tuple)
    end
36863
def add(self, key, value):
        """"""
        if key not in self.headers:
            self.headers[key] = []
        self.headers[key].append(value)

        if self.sent_time:
            self.modified_since_sent = True
929762
def append(self, item):
    
    if self.should_flush():
      self.flush()
    self.items.append(item)
1374360
def append(self, item):
        
        return self._client.rpush(self.key_prefix, self._dumps(item))
32442
def append(self, value):
        
        if not self.need_free:
            raise ValueError("Stack is read-only")
        if not isinstance(value, X509):
            raise TypeError('StackOfX509 can contain only X509 objects')
        sk_push(self.ptr, libcrypto.X509_dup(value.cert))
1043127
def put(self, key, value):
    '''
    '''
    if value is None:
      self.delete(key)
    else:
      self._collection(key)[key] = value
476332
def append(self, item):
        
        validated_value = self.get_validated_object(item)
        if validated_value is not None:
            self.__modified_data__.append(validated_value)
805503
def push(self, value=None):
        
        if not isinstance(value, Bottle):
            value = Bottle()
        self.append(value)
        return value
1109023
def __add_item(self, item, keys=None):
        
        if(not keys or not len(keys)):
            raise Exception('Error in %s.__add_item(%s, keys=tuple/list of items): need to specify a tuple/list containing at least one key!'
                            % (self.__class__.__name__, str(item)))
        direct_key = tuple(keys) # put all keys in a tuple, and use it as a key
        for key in keys:
            key_type = str(type(key))

            # store direct key as a value in an intermediate dictionary
            if(not key_type in self.__dict__):
                self.__setattr__(key_type, dict())
            self.__dict__[key_type][key] = direct_key

            # store the value in the actual dictionary
            if(not 'items_dict' in self.__dict__):
                self.items_dict = dict()
            self.items_dict[direct_key] = item
643664
def append(self, item):
        
        self.check_insertion(item)

        self.real_list.append(item)
        self._items |= {item}
1259297
def Append(self, item):
    
    if self._index >= self._size:
      self._index = self._index % self._size

    try:
      self._list[self._index] = item
    except IndexError:
      self._list.append(item)
    self._index += 1
1127801
def add(self, item):
        """"""
        if not item in self.items:
            self.items.append(item)
1036195
def _add_to_stack(self, item, value):
        
        p_value = (item, value)
        if p_value not in self.stack:
            self.stack.append(p_value)
211074
def put(self, item, **kwargs):
        """"""
        if self.full():
            raise Full()
        self._append(item)