;ς ΞΡAHc@sldZdklZdeidZeiZdgZdkZdk Z dk l Z dfd„ƒYZ dS(shMimic C structs with lots of extra functionality. $Id: ipstruct.py 1950 2006-11-28 19:15:35Z vivainio $(sReleases%s <%s>sFernandosStructN(s list2dict2cBs.tZdZdiƒZed„Zd„Zd„Zd„Z d„Z d„Z d„Z d „Z d „Zd „Zd „Zd „Zd„Zd„Zd„Zd„Zd„Zd„Zed„Zeed„Zd„Zd„Zd„Zd„Zed„Zed„Zed„Z e!d„Z"RS(s Class to mimic C structs but also provide convenient dictionary-like functionality. Instances can be initialized with a dictionary, a list of key=value pairs or both. If both are present, the dictionary must come first. Because Python classes provide direct assignment to their members, it's easy to overwrite normal methods (S.copy = 1 would destroy access to S.copy()). For this reason, all builtin method names are protected and can't be assigned to. An attempt to do s.copy=1 or s['copy']=1 will raise a KeyError exception. If you really want to, you can bypass this protection by directly assigning to __dict__: s.__dict__['copy']=1 will still work. Doing this will break functionality, though. As in most of Python, namespace protection is weakly enforced, so feel free to shoot yourself if you really want to. Note that this class uses more memory and is *much* slower than a regular dictionary, so be careful in situations where memory or performance are critical. But for day to day use it should behave fine. It is particularly convenient for storing configuration data in programs. +,+=,- and -= are implemented. +/+= do merges (non-destructive updates), -/-= remove keys from the original. See the method descripitions. This class allows a quick access syntax: both s.key and s['key'] are valid. This syntax has a limitation: each 'key' has to be explicitly accessed by its original name. The normal s.key syntax doesn't provide access to the keys via variables whose values evaluate to the desired keys. An example should clarify this: Define a dictionary and initialize both with dict and k=v pairs: >>> d={'a':1,'b':2} >>> s=Struct(d,hi=10,ho=20) The return of __repr__ can be used to create a new instance: >>> s Struct({'ho': 20, 'b': 2, 'hi': 10, 'a': 1}) __str__ (called by print) shows it's not quite a regular dictionary: >>> print s Struct {a: 1, b: 2, hi: 10, ho: 20} Access by explicitly named key with dot notation: >>> s.a 1 Or like a dictionary: >>> s['a'] 1 If you want a variable to hold the key value, only dictionary access works: >>> key='hi' >>> s.key Traceback (most recent call last): File "", line 1, in ? AttributeError: Struct instance has no attribute 'key' >>> s[key] 10 Another limitation of the s.key syntax (and Struct(key=val) initialization): keys can't be numbers. But numeric keys can be used and accessed using the dictionary syntax. Again, an example: This doesn't work: >>> s=Struct(4='hi') SyntaxError: keyword can't be an expression But this does: >>> s=Struct() >>> s[4]='hi' >>> s Struct({4: 'hi'}) >>> s[4] 'hi' stcopy dict dictcopy get has_attr has_key items keys merge popitem setdefault update values __make_dict __dict_invert cKs¦t|id<|tjo h}nt|tƒo|iƒ}n+|ot|ƒti j o t d‚n|i |ƒx$|i ƒD]\}}||| New Struct made form S and S.merge(S2)N(sselfscopysSoutsmergesother(sselfsothersSout((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys__add__£s  cCs|iƒ}||8}|SdS(sRReturn S1-S2, where all keys in S2 have been deleted (if present) from S1.N(sselfscopysSoutsother(sselfsothersSout((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys__sub__©s  cCs9x2|iƒD]$}|i|ƒo|i|=q q WdS(s^Do in place S = S - S2, meaning all keys in S2 have been deleted (if present) from S1.N(sotherskeyssksselfshas_keys__dict__(sselfsothersk((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys__isub__°s  cKs}|tjo h}nGt|ƒtijo |}n't|tƒo |i}n t d‚|o|i |ƒn|SdS(s>Helper function for update and merge. Return a dict from data.s.Update with a dict, a Struct or key=val pairs.N( s __loc_data__sNonesdictstypestypessDictTypes isinstancesStructs__dict__s TypeErrorskwsupdate(sselfs __loc_data__skwsdict((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys __make_dictΈs     cCslh}x[|iƒD]M\}}t|ƒtijo|iƒ}nx|D]}||| (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if S is empty.N(sselfs__dict__spopitem(sself((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pyspopitemδscKs@ti|||}x$|iƒD]\}}||| merge data and k=v into S. 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). conflict is a dictionary of binary functions which will be used to solve key conflicts. It must have the following structure: conflict == { fn1 : [Skey1,Skey2,...], fn2 : [Skey3], etc } Values must be lists or whitespace separated strings which are automatically converted to lists of strings by calling string.split(). Each key of conflict is a function which defines a policy for resolving conflicts when merging with the input data. Each fn must be a binary function which returns the desired outcome for a key conflict. These functions will be called as fn(old,new). An example is probably in order. Suppose you are merging the struct S with a dict D and the following conflict policy dict: S.merge(D,{fn1:['a','b',4], fn2:'key_c key_d'}) If the key 'a' is found in both S and D, the merge method will call: S['a'] = fn1(S['a'],D['a']) 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 works for strings! You can use those four words (as strings) as keys in conflict instead of defining them as functions, and the merge method will substitute the appropriate functions for you. That is, the call S.merge(D,{'preserve':'a b c','add':[4,5,'d'],my_function:[6]}) will automatically substitute the functions preserve and add for the names 'preserve' and 'add' before making any function calls. For more complicated conflict resolution policies, you still need to construct your own functions. cCs|S(N(sold(soldsnew((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys1scCs|S(N(snew(soldsnew((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys2scCs||S(N(soldsnew(soldsnew((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys3scCs||S(N(snewsold(soldsnew((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys4scCs |d|S(Ns (soldsnew(soldsnew((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys5ssdefaultspreservesupdatesaddsadd_flipsadd_sN(sStructs_Struct__make_dictsselfs __loc_data__skws data_dictspreservesupdatesaddsadd_flipsadd_ss list2dict2skeyssconflict_solves_Struct__conflict_solvescopysinv_conflict_solve_usersnamesfuncs_Struct__dict_invertskey(sselfs __loc_data__s_Struct__conflict_solveskwspreservesconflict_solvesnamesadd_ssupdatesadd_flipskeysaddsfuncsinv_conflict_solve_users data_dict((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pysmergeφs*5      4  cCs|ii|ƒSdS(s!Like has_key() dictionary method.N(sselfs__dict__shas_keyskey(sselfskey((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pyshas_keyNscCs|ii|ƒSdS(sΧhasattr function available as a method. Implemented like has_key, to make sure that all available keys in the internal dictionary of the Struct appear also as attributes (even numeric keys).N(sselfs__dict__shas_keyskey(sselfskey((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pyshasattrRscCs|iiƒSdS(s`Return the items in the Struct's dictionary, in the same format as a call to {}.items().N(sselfs__dict__sitems(sself((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pysitemsZscCs|iiƒSdS(s^Return the keys in the Struct's dictionary, in the same format as a call to {}.keys().N(sselfs__dict__skeys(sself((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pyskeys_scCsI| o|iiƒSn-g}x|D]}|i||ƒq&W|SdS(s@Return the values in the Struct's dictionary, in the same format as a call to {}.values(). Can be called with an optional argument keys, which must be a list or tuple of keys. In this case it returns only the values corresponding to those keys (allowing a form of 'slicing' for Structs).N(skeyssselfs__dict__svaluessretsksappend(sselfskeyssksret((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pysvaluesdscCs*y ||SWntj o |SnXdS(sBS.get(k[,d]) -> S[k] if S.has_key(k), else d. d defaults to None.N(sselfsattrsKeyErrorsval(sselfsattrsval((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pysgetss  cCs3|i|ƒ o||| S.get(k,d), also set S[k]=d if not S.has_key(k)N(sselfshas_keysattrsvalsget(sselfsattrsval((s@/nyx/web/d/b/dbachman/work/src/ipython-0.8.4/IPython/ipstruct.pys setdefaultzscCs||d