我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用collections.MutableMapping()。
def view(tpl_name, **defaults): ''' Decorator: renders a template for a handler. The handler can control its behavior like that: - return a dict of template vars to fill out the template - return something other than a dict and the view decorator will not process the template, but return the handler result as is. This includes returning a HTTPResponse(dict) to get, for instance, JSON with autojson or other castfilters. ''' def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): result = func(*args, **kwargs) if isinstance(result, (dict, DictMixin)): tplvars = defaults.copy() tplvars.update(result) return template(tpl_name, **tplvars) elif result is None: return template(tpl_name, defaults) return result return wrapper return decorator
def view(tpl_name, **defaults): """ Decorator: renders a template for a handler. The handler can control its behavior like that: - return a dict of template vars to fill out the template - return something other than a dict and the view decorator will not process the template, but return the handler result as is. This includes returning a HTTPResponse(dict) to get, for instance, JSON with autojson or other castfilters. """ def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): result = func(*args, **kwargs) if isinstance(result, (dict, DictMixin)): tplvars = defaults.copy() tplvars.update(result) return template(tpl_name, **tplvars) elif result is None: return template(tpl_name, defaults) return result return wrapper return decorator
def flatten_dict(d, parent_key='', sep='_'): """Flattens a nested dictionary. :param d: A nested dictionary :type d: dict or MutableMapping :param str parent_key: The parent's key. This is a value for tail recursion, so don't set it yourself. :param str sep: The separator used between dictionary levels .. seealso:: http://stackoverflow.com/a/6027615 """ items = [] for k, v in d.items(): new_key = parent_key + sep + k if parent_key else k if isinstance(v, (dict, MutableMapping)): items.extend(flatten_dict(v, new_key, sep=sep).items()) elif isinstance(v, (set, list)): items.append((new_key, ','.join(v))) else: items.append((new_key, v)) return dict(items)
def rec_merge(d1, d2): """ Update two dicts of dicts recursively, if either mapping has leaves that are non-dicts, the second's leaf overwrites the first's. """ # in Python 2, use .iteritems()! for k, v in d1.items(): if k in d2: # this next check is the only difference! if all(isinstance(e, MutableMapping) for e in (v, d2[k])): d2[k] = rec_merge(v, d2[k]) if isinstance(v, list): d2[k].extend(v) # we could further check types and merge as appropriate here. d3 = d1.copy() d3.update(d2) return d3
def _flatten_dict(dict_, parent_key="", sep="."): """Flattens a nested dictionary. Namedtuples within the dictionary are converted to dicts. Args: dict_: The dictionary to flatten. parent_key: A prefix to prepend to each key. sep: Separator between parent and child keys, a string. For example { "a": { "b": 3 } } will become { "a.b": 3 } if the separator is ".". Returns: A new flattened dictionary. """ items = [] for key, value in dict_.items(): new_key = parent_key + sep + key if parent_key else key if isinstance(value, collections.MutableMapping): items.extend(_flatten_dict(value, new_key, sep=sep).items()) elif isinstance(value, tuple) and hasattr(value, "_asdict"): dict_items = collections.OrderedDict(zip(value._fields, value)) items.extend(_flatten_dict(dict_items, new_key, sep=sep).items()) else: items.append((new_key, value)) return dict(items)
def view(tpl_name, **defaults): ''' Decorator: renders a template for a handler. The handler can control its behavior like that: - return a dict of template vars to fill out the template - return something other than a dict and the view decorator will not process the template, but return the handler result as is. This includes returning a HTTPResponse(dict) to get, for instance, JSON with autojson or other castfilters. ''' def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): result = func(*args, **kwargs) if isinstance(result, (dict, DictMixin)): tplvars = defaults.copy() tplvars.update(result) return template(tpl_name, **tplvars) return result return wrapper return decorator
def merge_dicts(d1: dict, d2: dict) -> dict: """ Update two dicts of dicts recursively, if either mapping has leaves that are non-dicts, the second's leaf overwrites the first's. """ # in Python 2, use .iteritems()! for k, v in d1.items(): if k in d2: # this next check is the only difference! if all(isinstance(e, MutableMapping) for e in (v, d2[k])): d2[k] = merge_dicts(v, d2[k]) if isinstance(v, list): d2[k].extend(v) # we could further check types and merge as appropriate here. d3 = d1.copy() d3.update(d2) return d3
def preprocess_vars(a): ''' Ensures that vars contained in the parameter passed in are returned as a list of dictionaries, to ensure for instance that vars loaded from a file conform to an expected state. ''' if a is None: return None elif not isinstance(a, list): data = [ a ] else: data = a for item in data: if not isinstance(item, MutableMapping): raise AnsibleError("variable files must contain either a dictionary of variables, or a list of dictionaries. Got: %s (%s)" % (a, type(a))) return data
def _preprocess_vars(self, a): ''' Ensures that vars contained in the parameter passed in are returned as a list of dictionaries, to ensure for instance that vars loaded from a file conform to an expected state. ''' if a is None: return None elif not isinstance(a, list): data = [ a ] else: data = a for item in data: if not isinstance(item, MutableMapping): raise AnsibleError("variable files must contain either a dictionary of variables, or a list of dictionaries. Got: %s (%s)" % (a, type(a))) return data
def _validate_mutable_mappings(a, b): """ Internal convenience function to ensure arguments are MutableMappings This checks that all arguments are MutableMappings or raises an error :raises AnsibleError: if one of the arguments is not a MutableMapping """ # If this becomes generally needed, change the signature to operate on # a variable number of arguments instead. if not (isinstance(a, MutableMapping) and isinstance(b, MutableMapping)): myvars = [] for x in [a, b]: try: myvars.append(dumps(x)) except: myvars.append(to_native(x)) raise AnsibleError("failed to combine variables, expected dicts but got a '{0}' and a '{1}': \n{2}\n{3}".format( a.__class__.__name__, b.__class__.__name__, myvars[0], myvars[1]) )
def merge_dict(target, *sources): """ Merge the given list of `Mapping` objects into `target` object. :param MutableMapping target: The mapping to receive the merge. :param tuple sources: The list of `mapping` objects to be merged. """ for source in sources: if not isinstance(target, MutableMapping): raise TypeError('target must be a dict') if not isinstance(source, Mapping): raise TypeError('data must be a dict') for key in source: target_value = target.get(key) source_value = source[key] if target_value is None or source_value is None: target[key] = source_value elif isinstance(target_value, Mapping) and isinstance(source_value, Mapping): merge_dict(target_value, source_value) else: target[key] = source_value
def _to_dict(self, o): """ Convert a given object to dict. :param o: The object to be converted. :return dict: The dict value converted. """ if isinstance(o, MutableMapping): return o if not isinstance(o, string_types): raise TypeError('Expected str, got %s' % text_type(type(o))) pairs = o.split(self.dict_delimiter) d = IgnoreCaseDict() for pair in pairs: kv = pair.split('=') key = kv[0].strip() value = kv[1].strip() d[key] = value return d
def __init__(self, func, items, cache=True): """Applies the given function on the given items at the moment of data request. On the moment one of the keys of this dict class is requested we apply the given function on the given items and return the result of that function. The advantage of this class is that it defers an expensive operation until it is needed. Items added to this dictionary after creation are assumed to be final, that is, we won't run the function on them. Args: func (Function): the callback function to apply on the given items at request, with signature: .. code-block:: python def callback(key, value) items (collections.MutableMapping): the items on which we operate cache (boolean): if we want to cache computed results """ self._func = func self._items = copy.copy(items) self._applied_on_key = {} self._cache = cache
def __init__(self, items, cache=True): """The items should contain a list of functions that we apply at the moment of request. On the moment one of the keys of this dict class is requested we apply the function stored in the items dict for that key and return the result of that function. The advantage of this class is that it defers an expensive operation until it is needed. Items set to this dictionary are assumed to be final, that is, we won't run the function on them. Args: items (collections.MutableMapping): the items on which we operate, each value should contain a function with no parameters that we run to return the results. cache (boolean): if we want to cache computed results """ self._items = copy.copy(items) self._applied_on_key = {} self._cache = cache
def _flatten_dict(dict_, parent_key="", sep="."): """Flattens a nested dictionary. Namedtuples within the dictionary are converted to dicts. Args: dict_: The dictionary to flatten. parent_key: A prefix to prepend to each key. sep: Separator between parent and child keys, a string. For example { "a": { "b": 3 } } will become { "a.b": 3 } if the separator is ".". Returns: A new flattened dictionary. """ items = [] for key, value in dict_.items(): new_key = parent_key + sep + key if parent_key else key if isinstance(value, collections.MutableMapping): items.extend(_flatten_dict(value, new_key, sep=sep).items()) elif isinstance(value, tuple) and hasattr(value, "_asdict"): dict_items = collections.OrderedDict(zip(value._fields, value)) items.extend(_flatten_dict( dict_items, new_key, sep=sep).items()) else: items.append((new_key, value)) return dict(items)
def transform_incoming(self, son, collection): """Replace embedded documents with DBRefs. """ def transform_value(value): if isinstance(value, collections.MutableMapping): if "_id" in value and "_ns" in value: return DBRef(value["_ns"], transform_value(value["_id"])) else: return transform_dict(SON(value)) elif isinstance(value, list): return [transform_value(v) for v in value] return value def transform_dict(object): for (key, value) in object.items(): object[key] = transform_value(value) return object return transform_dict(SON(son))
def transform_outgoing(self, son, collection): """Replace DBRefs with embedded documents. """ def transform_value(value): if isinstance(value, DBRef): return self.database.dereference(value) elif isinstance(value, list): return [transform_value(v) for v in value] elif isinstance(value, collections.MutableMapping): return transform_dict(SON(value)) return value def transform_dict(object): for (key, value) in object.items(): object[key] = transform_value(value) return object return transform_dict(SON(son)) # TODO make a generic translator for custom types. Take encode, decode, # should_encode and should_decode functions and just encode and decode where # necessary. See examples/custom_type.py for where this would be useful. # Alternatively it could take a should_encode, to_binary, from_binary and # binary subtype.
def get_obj(value, actual_type): actual_type = str_to_class(actual_type.decode('utf-8')) if py3: if actual_type is not bytes: value = value.decode('utf-8') else: if actual_type is unicode: value = value.decode('utf-8') if actual_type in {Decimal, complex}: value = actual_type(value) elif actual_type is datetime.datetime: value = datetime.datetime.strptime(value, DATETIME_FORMAT) elif actual_type is datetime.date: value = datetime.datetime.strptime(value, DATE_FORMAT).date() elif actual_type in {dict, list} or isinstance(actual_type, (MutableMapping, Iterable)): value = json.loads(value) else: value = actual_type(value) return value
def __save_in_redis(self, path, value): if isinstance(value, strings): value = self.doformat(value) self.red.set(path, value) elif isinstance(value, sets): value = self.doformat(value) self.red.delete(path) self.red.sadd(path, *value) elif isinstance(value, numbers): value = self.doformat(value) self.red.set(path, value) elif isinstance(value, MutableMapping): value = self.doformat(value) self.red.hmset(path, value) elif isinstance(value, Iterable): value = self.doformat(value) self.red.delete(path) self.red.rpush(path, *value) else: value = self.doformat(value, the_type="obj") self.red.set(path, value)
def flatten(d, parent_key='', sep='_'): """ Flatten keys in a dictionary Example: flatten({'a': 1, 'c': {'a': 2, 'b': {'x': 5, 'y' : 10}}, 'd': [1, 2, 3]}) => {'a': 1, 'c_a': 2, 'c_b_x': 5, 'd': [1, 2, 3], 'c_b_y': 10} :param d: Dictionary to flatten :param sep: Separator between keys :param parent_key: Key to merge with """ items = [] for k, v in d.items(): new_key = parent_key + sep + k if parent_key else k if isinstance(v, collections.MutableMapping): items.extend(flatten(v, new_key, sep=sep).items()) else: items.append((new_key, v)) return dict(items)
def __init__(self, *args, **kwargs): # collections.MutableMapping.__init__(self) super(DerivedDictBase, self).__init__() # super(SolutionDict, self).__init__() # the same self.data = dict() self.data.update(dict(*args, **kwargs))
def validate_document_class(option, value): """Validate the document_class option.""" if not issubclass(value, (collections.MutableMapping, RawBSONDocument)): raise TypeError("%s must be dict, bson.son.SON, " "bson.raw_bson.RawBSONDocument, or a " "sublass of collections.MutableMapping" % (option,)) return value
def validate_is_document_type(option, value): """Validate the type of method arguments that expect a MongoDB document.""" if not isinstance(value, (collections.MutableMapping, RawBSONDocument)): raise TypeError("%s must be an instance of dict, bson.son.SON, " "bson.raw_bson.RawBSONDocument, or " "a type that inherits from " "collections.MutableMapping" % (option,))
def __new__(cls, document_class=dict, tz_aware=False, uuid_representation=PYTHON_LEGACY, unicode_decode_error_handler="strict", tzinfo=None): if not (issubclass(document_class, MutableMapping) or _raw_document_class(document_class)): raise TypeError("document_class must be dict, bson.son.SON, " "bson.raw_bson_document.RawBSONDocument, or a " "sublass of collections.MutableMapping") if not isinstance(tz_aware, bool): raise TypeError("tz_aware must be True or False") if uuid_representation not in ALL_UUID_REPRESENTATIONS: raise ValueError("uuid_representation must be a value " "from bson.binary.ALL_UUID_REPRESENTATIONS") if not isinstance(unicode_decode_error_handler, (string_type, None)): raise ValueError("unicode_decode_error_handler must be a string " "or None") if tzinfo is not None: if not isinstance(tzinfo, datetime.tzinfo): raise TypeError( "tzinfo must be an instance of datetime.tzinfo") if not tz_aware: raise ValueError( "cannot specify tzinfo without also setting tz_aware=True") return tuple.__new__( cls, (document_class, tz_aware, uuid_representation, unicode_decode_error_handler, tzinfo))
def modifies_known_mutable(obj, attr): """This function checks if an attribute on a builtin mutable object (list, dict, set or deque) would modify it if called. It also supports the "user"-versions of the objects (`sets.Set`, `UserDict.*` etc.) and with Python 2.6 onwards the abstract base classes `MutableSet`, `MutableMapping`, and `MutableSequence`. >>> modifies_known_mutable({}, "clear") True >>> modifies_known_mutable({}, "keys") False >>> modifies_known_mutable([], "append") True >>> modifies_known_mutable([], "index") False If called with an unsupported object (such as unicode) `False` is returned. >>> modifies_known_mutable("foo", "upper") False """ for typespec, unsafe in _mutable_spec: if isinstance(obj, typespec): return attr in unsafe return False
def flatten(d, parent_key='', sep='__'): items = [] for k, v in d.items(): new_key = parent_key + sep + k if parent_key else k if isinstance(v, collections.MutableMapping): items.extend(flatten(v, new_key, sep=sep).items()) else: items.append((new_key, str(v) if type(v) is list else v)) return dict(items)
def parse(cls, headers): """Returns a dictionary from HTTP header text. >>> h = HTTPHeaders.parse("Content-Type: text/html\\r\\nContent-Length: 42\\r\\n") >>> sorted(h.items()) [('Content-Length', '42'), ('Content-Type', 'text/html')] """ h = cls() for line in _CRLF_RE.split(headers): if line: h.parse_line(line) return h # MutableMapping abstract method implementations.
def copy(self): # defined in dict but not in MutableMapping. return HTTPHeaders(self) # Use our overridden copy method for the copy.copy module. # This makes shallow copies one level deeper, but preserves # the appearance that HTTPHeaders is a single container.
