Module: utils.ipstruct
¶
A dict subclass that supports attribute style access.
Authors:
- Fernando Perez (original)
- Brian Granger (refactoring to a dict subclass)
1 Class¶
-
class
IPython.utils.ipstruct.
Struct
(*args, **kw)¶ Bases:
dict
A dict subclass with attribute style access.
This dict subclass has a a few extra features:
- Attribute style access.
- Protection of class members (like keys, items) when using attribute style access.
- The ability to restrict assignment to only existing keys.
- Intelligent merging.
- Overloaded operators.
-
__init__
(*args, **kw)¶ Initialize with a dictionary, another Struct, or data.
Parameters: - args (dict, Struct) – Initialize with one dict or Struct
- kw (dict) – Initialize with key, value pairs.
Examples
>>> s = Struct(a=10,b=30) >>> s.a 10 >>> s.b 30 >>> s2 = Struct(s,c=30) >>> sorted(s2.keys()) ['a', 'b', 'c']
-
__add__
(other)¶ s + s2 -> New Struct made from s.merge(s2).
Examples
>>> s1 = Struct(a=10,b=30) >>> s2 = Struct(a=20,c=40) >>> s = s1 + s2 >>> sorted(s.keys()) ['a', 'b', 'c']
-
__getattr__
(key)¶ Get an attr by calling
dict.__getitem__()
.Like
__setattr__()
, this method convertsKeyError
toAttributeError
.Examples
>>> s = Struct(a=10) >>> s.a 10 >>> type(s.get) <... 'builtin_function_or_method'> >>> try: ... s.b ... except AttributeError: ... print("I don't have that key") ... I don't have that key
-
__iadd__
(other)¶ s += s2 is a shorthand for s.merge(s2).
Examples
>>> s = Struct(a=10,b=30) >>> s2 = Struct(a=20,c=40) >>> s += s2 >>> sorted(s.keys()) ['a', 'b', 'c']
-
__isub__
(other)¶ Inplace remove keys from self that are in other.
Examples
>>> s1 = Struct(a=10,b=30) >>> s2 = Struct(a=40) >>> s1 -= s2 >>> s1 {'b': 30}
-
__setattr__
(key, value)¶ Set an attr with protection of class members.
This calls
self.__setitem__()
but convertKeyError
toAttributeError
.Examples
>>> s = Struct() >>> s.a = 10 >>> s.a 10 >>> try: ... s.get = 10 ... except AttributeError: ... print("you can't set a class member") ... you can't set a class member
-
__setitem__
(key, value)¶ Set an item with check for allownew.
Examples
>>> s = Struct() >>> s['a'] = 10 >>> s.allow_new_attr(False) >>> s['a'] = 10 >>> s['a'] 10 >>> try: ... s['b'] = 20 ... except KeyError: ... print('this is not allowed') ... this is not allowed
-
__sub__
(other)¶ s1 - s2 -> remove keys in s2 from s1.
Examples
>>> s1 = Struct(a=10,b=30) >>> s2 = Struct(a=40) >>> s = s1 - s2 >>> s {'b': 30}
-
allow_new_attr
(allow=True)¶ Set whether new attributes can be created in this Struct.
This can be used to catch typos by verifying that the attribute user tries to change already exists in this Struct.
-
copy
()¶ Return a copy as a Struct.
Examples
>>> s = Struct(a=10,b=30) >>> s2 = s.copy() >>> type(s2) is Struct True
-
hasattr
(key)¶ hasattr function available as a method.
Implemented like has_key.
Examples
>>> s = Struct(a=10) >>> s.hasattr('a') True >>> s.hasattr('b') False >>> s.hasattr('get') False
-
merge
(__loc_data__=None, _Struct__conflict_solve=None, **kw)¶ Merge two Structs with customizable conflict resolution.
This is similar to
update()
, but much more flexible. First, a dict is made from data+key=value pairs. When merging this dict with the Struct S, the optional dictionary ‘conflict’ is used to decide what to do.If conflict is not given, the default behavior is to preserve any keys with their current value (the opposite of the
update()
method’s behavior).Parameters: - __loc_data (dict, Struct) – The data to merge into self
- __conflict_solve (dict) – The conflict policy dict. The keys are binary functions used to resolve the conflict and the values are lists of strings naming the keys the conflict resolution function applies to. Instead of a list of strings a space separated string can be used, like ‘a b c’.
- kw (dict) – Additional key, value pairs to merge in
Notes
The
__conflict_solve
dict is a dictionary of binary functions which will be used to solve key conflicts. Here is an example:__conflict_solve = dict( func1=['a','b','c'], func2=['d','e'] )
In this case, the function
func1()
will be used to resolve keys ‘a’, ‘b’ and ‘c’ and the functionfunc2()
will be used for keys ‘d’ and ‘e’. This could also be written as:__conflict_solve = dict(func1='a b c',func2='d e')
These functions will be called for each key they apply to with the form:
func1(self['a'], other['a'])
The return value is used as the final merged value.
As a convenience, merge() provides five (the most commonly needed) pre-defined policies: preserve, update, add, add_flip and add_s. The easiest explanation is their implementation:
preserve = lambda old,new: old update = lambda old,new: new add = lambda old,new: old + new add_flip = lambda old,new: new + old # note change of order! add_s = lambda old,new: old + ' ' + new # only for str!
You can use those four words (as strings) as keys instead of defining them as functions, and the merge method will substitute the appropriate functions for you.
For more complicated conflict resolution policies, you still need to construct your own functions.
Examples
This show the default policy:
>>> s = Struct(a=10,b=30) >>> s2 = Struct(a=20,c=40) >>> s.merge(s2) >>> sorted(s.items()) [('a', 10), ('b', 30), ('c', 40)]
Now, show how to specify a conflict dict:
>>> s = Struct(a=10,b=30) >>> s2 = Struct(a=20,b=40) >>> conflict = {'update':'a','add':'b'} >>> s.merge(s2,conflict) >>> sorted(s.items()) [('a', 20), ('b', 70)]