Update the dict with the dict tree in parameter d.

        Parameters
        ----------
        d : dict
          New dict content
779655
def update(self, d):
        

        # Call __setitem__ for all keys in d
        for key in list(d.keys()):
            self.__setitem__(key, d[key])
347310
def pdudata_contents(self, use_dict=None, as_class=dict):
        """"""
        if _debug: PDUData._debug("pdudata_contents use_dict=%r as_class=%r", use_dict, as_class)

        # make/extend the dictionary of content
        if use_dict is None:
            use_dict = as_class()

        # add the data if it is not None
        v = self.pduData
        if v is not None:
            if isinstance(v, str):
                v = btox(v)
            elif hasattr(v, 'dict_contents'):
                v = v.dict_contents(as_class=as_class)
            use_dict.__setitem__('data', v)

        # return what we built/updated
        return use_dict
27251
def update_model_dict(self):
        """"""
        dct = {}
        models = self.chimera.openModels
        for md in models.list():
            dct[md.name] = md.id
        self.model_dict = dct
613360
def deep_update_dict(default, options):
    
    for key in options.keys():
        default_setting = default.get(key)
        new_setting = options.get(key)
        if isinstance(default_setting, dict):
            deep_update_dict(default_setting, new_setting)
        else:
            default[key] = new_setting
1071841
def update_dict_id_field_from_response_field(cls, dict_, dict_id_field,
                                                 response_obj, response_field,
                                                 response_param):
        

        url = response_obj[response_field]

        if url is not None:
            url_parsed = urlparse.urlparse(url)
            parameters = urlparse.parse_qs(url_parsed.query)
            dict_[dict_id_field] = int(
                parameters[response_param][cls._INDEX_FIRST]
            )

            if cls._FIELD_COUNT in parameters and cls._FIELD_COUNT not in dict_:
                dict_[cls._FIELD_COUNT] = int(
                    parameters[client.Pagination.PARAM_COUNT][cls._INDEX_FIRST]
                )
509683
def update_from_dict(self, dct):
        
        if not dct:
            return
        all_props = self.__class__.CONFIG_PROPERTIES
        for key, value in six.iteritems(dct):
            attr_config = all_props.get(key)
            if attr_config:
                setattr(self, key, value)
            else:
                self.update_default_from_dict(key, value)
1020250
def update_without_overwrite(d, *args, **kwds):
    
    if args:
        assert len(args) == 1, \
            'At most one positional parameter is allowed: {0!r}'.format(args)

        (other,) = args
        if isinstance(other, Mapping):
            for key in other:
                setitem_without_overwrite(d, key, other[key])
        elif hasattr(other, "keys"):
            for key in other.keys():
                setitem_without_overwrite(d, key, other[key])
        else:
            for key, value in other:
                setitem_without_overwrite(d, key, value)

    for key, value in kwds.items():
        setitem_without_overwrite(d, key, value)
1073192
def t_insert_dict_if_new(self, tblname, d, PKfields, fields=None):
        ''''''
        SQL, values = self._insert_dict_if_new_inner(tblname, d, PKfields, fields=fields)
        if SQL != False:
            self.execute_select(SQL, parameters=values, locked=True)
            return True, d
        return False, values
1266291
def update(self, u):
        ''' 
        '''
        for k, v in u.iteritems():
            if isinstance(v, collections.Mapping):
                r = nested_dict.from_dict(self.get(k, {}))
                r.update(v)
                self[k] = r
            elif isinstance(self, collections.Mapping):
                self[k] = u[k]
            else:
                self.__dict__ = dict(k = u[k])
469919
def update(self, other=None, **kwargs):
        ''''''
        copydict = ImmutableDict()
        if other:
            vallist = [(hash(key), (key, other[key])) for key in other]
        else: vallist = []
        if kwargs:
            vallist += [(hash(key), (key, kwargs[key])) for key in kwargs]
        copydict.tree = self.tree.multi_assoc(vallist)
        copydict._length = iter_length(copydict.tree)
        return copydict
170438
def _update_dictionary(self):
        
        self._total_words = sum(self._dictionary.values())
        self._unique_words = len(self._dictionary.keys())
        self._letters = set()
        for key in self._dictionary:
            self._letters.update(key)
76625
def update(self, dict_):
        
        for key, value in dict_.items():
            index = self.column_index.get(key, None)
            if index is not None:
                list.__setitem__(self, index, value)
1253785
def update_from_dict(self, attribute_dict):
        
        if 'template' in attribute_dict:
            self.update_from_dict(attribute_dict['template'])
            setattr(self,
                    self.Meta.id_field, attribute_dict['template']['name'])
            return
        try:
            for k, v in attribute_dict.items():
                setattr(self, k, v)
        except Exception:
            setattr(self, self.Meta.id_field, attribute_dict)
815270
def dict_expand(d, prefix=None):
    
    result = {}
    for k, v in d.items():
        if isinstance(v, dict):
            result.update(dict_expand(v, prefix=k))
        else:
            result[k] = v

    if prefix is not None:
        result = {make_tuple(prefix) + make_tuple(k): v
                  for k, v in result.items()}
    return result
478953
def update(self, other=(), **kwargs):
        ''''''
        _kwargs = dict(kwargs)
        _kwargs.update(other)
        for key, value in _kwargs.items():
            self[key] = value
814793
def merge_dicts(base, updates):
    
    if not base:
        base = dict()
    if not updates:
        updates = dict()
    z = base.copy()
    z.update(updates)
    return z
1058503
def update_context(self, ctx):
        
        assert isinstance(ctx, dict)
        ctx[str(self.context_id)] = self.value