docs: def set_attributes(self, el, pyobj):
          '''Instance data attributes contains a dictionary 
          of keys (namespaceURI,localName) and attribute values.
          These values can be self-describing (typecode), or use
          attribute_typecode_dict to determine serialization.
          Paramters:
              el -- MessageInterface representing the element
              pyobj -- 
          '''
          if not hasattr(pyobj, self.attrs_aname):
              return
  
          if not isinstance(getattr(pyobj, self.attrs_aname), dict):
              raise TypeError,\
                  'pyobj.%s must be a dictionary of names and values'\
                  % self.attrs_aname
  
          for attr, value in getattr(pyobj, self.attrs_aname).items():
              namespaceURI,localName = None, attr
              if type(attr) in _seqtypes:
                  namespaceURI, localName = attr
  
              what = None
              if getattr(self, 'attribute_typecode_dict', None) is not None:
                  what = self.attribute_typecode_dict.get(attr)
                  if what is None and namespaceURI is None:
                      what = self.attribute_typecode_dict.get(localName)
  
              # allow derived type
              if hasattr(value, 'typecode') and not isinstance(what, AnyType):
                  if what is not None and not isinstance(value.typecode, what):
                      raise EvaluateException, \
                          'self-describing attribute must subclass %s'\
                          %what.__class__
  
                  what = value.typecode
                  
              self.logger.debug("attribute create -- %s", value)
              if isinstance(what, QName):
                  what.set_prefix(el, value)
              
              #format the data
              if what is None:
                  value = str(value)
              else:
                  value = what.get_formatted_content(value)
  
              el.setAttributeNS(namespaceURI, localName, value)