Update the dictionary from *other*, overwriting existing keys.
186053
def update(self, *args, **kwargs):
        """"""
        self._extend(args, kwargs, 'update', self._update_items)
316957
def _dict_increment(self, dictionary, key):
        """"""
        if key in dictionary:
            dictionary[key] += 1
        else:
            dictionary[key] = 1
1307879
def _update_dict(self, initial: JSON, other: Mapping) -> JSON:
        
        for key, value in other.items():
            if isinstance(value, collections.Mapping):
                r = self._update_dict(initial.get(key, {}), value)
                initial[key] = r
            else:
                initial[key] = other[key]
        return initial
202653
def merge_dict(dict_1, *other, **kw):
    """"""
    tmp = dict_1.copy()
    for x in other:
        tmp.update(x)
    tmp.update(kw)
    return tmp
871448
def rename_keys(record: Mapping, key_map: Mapping) -> dict:
    """"""

    new_record = dict()

    for k, v in record.items():
        key = key_map[k] if k in key_map else k
        new_record[key] = v

    return new_record
686657
async def update(self):
    '''
    
    '''
    keys = self.extras.keys()
    self.extras = {}
    for key in keys:
      try:
        func = getattr(self, key, None)
        if callable(func):
          func()
      except:
        pass
137065
def update(self, other):
        

        self.globals.update(other.globals)
        self.locals.update(other.locals)
        return self
1214340
def update(self, other, copy=True, *args, **kwargs):
        """"""

        if other:  # dirty hack for python2.6

            if isinstance(other, self.__class__):

                if copy:
                    other = other.copy(*args, **kwargs)

                for slot in other.__slots__:
                    attr = getattr(other, slot)
                    if attr is not None:
                        setattr(self, slot, attr)

            else:
                raise TypeError(
                    'Wrong element to update with {0}: {1}'.format(self, other)
                )

        return self
1351606
def update(self, instance, oldValue, newValue, subKey):
    """"""
    histogram = self.__get__(instance, None)
    histogram[subKey] += newValue - oldValue
125963
def difference_update(self, *others):
        """"""
        self.db.sdiffstore(self.key, [o.key for o in [self.key] + others])
188708
def update(self, other):
        
        def update_trans(pipe):
            other_items = method(pipe=pipe) if use_redis else method()

            pipe.multi()
            for member, score in other_items:
                pipe.zadd(self.key, {self._pickle(member): float(score)})

        watches = []
        if self._same_redis(other, RedisCollection):
            use_redis = True
            watches.append(other.key)
        else:
            use_redis = False

        if hasattr(other, 'items'):
            method = other.items
        elif hasattr(other, '__iter__'):
            method = other.__iter__

        self._transaction(update_trans, *watches)
300560
def update(self, *args, **kwargs):
        '''
        
        '''
        preprocess = kwargs.get('preprocess')
        for s in args:
            for e in s:
                self._dict_set(preprocess(e) if preprocess else e, True)
222312
def update(self, key=values.unset, value=values.unset):
        
        return self._proxy.update(key=key, value=value, )
961765
def extend(a: dict, b: dict) -> dict:
    """"""
    res = a.copy()
    res.update(b)
    return res
489727
def dict_update_overwrite_check(base, fresh):
    

    result = [
        (key, base[key], fresh[key])
        for key in set(base.keys()) & set(fresh.keys())
        if base[key] != fresh[key]
    ]
    base.update(fresh)
    return result
973644
def update(self, other):
        """"""
        if isinstance(other, self.__class__):
            return self.client.sunionstore(self.name, [self.name, other.name])
        else:
            return map(self.add, other)
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self