parameters: (self, __loc_data__=None, __conflict_solve=None, **kw)
docstring: Merge two Structs with customizable conflict resolution.
  
          This is similar to :meth:`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 :meth:`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 :func:`func1` will be used to resolve
          keys 'a', 'b' and 'c' and the function :func:`func2` 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)]
docstring_summary: Merge two Structs with customizable conflict resolution.
docstring_tokens: Merge two Structs with customizable conflict resolution .
function: def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
          """Merge two Structs with customizable conflict resolution.
  
          This is similar to :meth:`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 :meth:`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 :func:`func1` will be used to resolve
          keys 'a', 'b' and 'c' and the function :func:`func2` 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)]
          """
  
          data_dict = dict(__loc_data__,**kw)
  
          # policies for conflict resolution: two argument functions which return
          # the value that will go in the new struct
          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
  
          # default policy is to keep current keys when there's a conflict
          conflict_solve = dict.fromkeys(self, preserve)
  
          # the conflict_solve dictionary is given by the user 'inverted': we
          # need a name-function mapping, it comes as a function -> names
          # dict. Make a local copy (b/c we'll make changes), replace user
          # strings for the three builtin policies and invert it.
          if __conflict_solve:
              inv_conflict_solve_user = __conflict_solve.copy()
              for name, func in [('preserve',preserve), ('update',update),
                                 ('add',add), ('add_flip',add_flip),
                                 ('add_s',add_s)]:
                  if name in inv_conflict_solve_user.keys():
                      inv_conflict_solve_user[func] = inv_conflict_solve_user[name]
                      del inv_conflict_solve_user[name]
              conflict_solve.update(self.__dict_invert(inv_conflict_solve_user))
          for key in data_dict:
              if key not in self:
                  self[key] = data_dict[key]
              else:
                  self[key] = conflict_solve[key](self[key],data_dict[key])
function_tokens: def merge ( self , __loc_data__ = None , __conflict_solve = None , * * kw ) : data_dict = dict ( __loc_data__ , * * kw ) # policies for conflict resolution: two argument functions which return # the value that will go in the new struct 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 # default policy is to keep current keys when there's a conflict conflict_solve = dict . fromkeys ( self , preserve ) # the conflict_solve dictionary is given by the user 'inverted': we # need a name-function mapping, it comes as a function -> names # dict. Make a local copy (b/c we'll make changes), replace user # strings for the three builtin policies and invert it. if __conflict_solve : inv_conflict_solve_user = __conflict_solve . copy ( ) for name , func in [ ( 'preserve' , preserve ) , ( 'update' , update ) , ( 'add' , add ) , ( 'add_flip' , add_flip ) , ( 'add_s' , add_s ) ] : if name in inv_conflict_solve_user . keys ( ) : inv_conflict_solve_user [ func ] = inv_conflict_solve_user [ name ] del inv_conflict_solve_user [ name ] conflict_solve . update ( self . __dict_invert ( inv_conflict_solve_user ) ) for key in data_dict : if key not in self : self [ key ] = data_dict [ key ] else : self [ key ] = conflict_solve [ key ] ( self [ key ] , data_dict [ key ] )