Python sudsobject.asdict函数代码示例

def suds_to_dict(obj):
  """Converts a suds object instance to a dict."""
  mapping = _SUDS_MAP.get(obj.__class__.__name__)
  if mapping is None:
    return sudsobject.asdict(obj)
  return dict(
      (mapping[k], v) for k, v in sudsobject.asdict(obj).items() if k in mapping
  )

def convert_entity_to_dict(entity):
    if has_udfs(entity):
        udfs = get_udfs(entity)
        udfs_list = []
        for udf in udfs:
            udfs_list.append(asdict(udf))
        entity.UserDefinedFields = udfs_list
    else:
        del_user_defined_fields_attribute(entity)
    return asdict(entity)

    def recursive_asdict(self, d):
        from suds.sudsobject import asdict

        """Convert Suds object into serializable format."""
        out = {}
        if type(d) is not dict:
            d = asdict(d)

        for k, v in d.items():
            if hasattr(v, '__keylist__'):
                out[k] = self.recursive_asdict(v)
            elif isinstance(v, list):
                out[k] = []
                for item in v:
                    if hasattr(item, '__keylist__'):
                        out[k].append(self.recursive_asdict(item))
                    else:
                        out[k].append(item)

            elif v:
                # if v is True or k in ['lastModifiedDate', 'createdDate', 'lastPublishedDate']:
                # print (k, v)
                try:
                    # out[k] = BeautifulStoneSoup(v)
                    out[k] = v.encode('ascii', 'xmlcharrefreplace')
                except:
                    out[k] = v
                # else:

                # uni = self.HTMLEntitiesToUnicode(v)
                # htmlent = self.unicodeToHTMLEntities(uni)
                # out[k] = htmlent

        return out

def remove_default_tags(d):
    out = {}
    for k, v in asdict(d).items():
        if k not in ('_ctiid', '_uuid'):
            if v:
                if v not in ('None', '', 'Default'):
                    if hasattr(v, '__keylist__'):
                        if hasattr(v, 'value'):
                            if v.value:
                                if v.value not in ('None', '', 'Default'):
                                    out[k] = v.value
                        else:
                            out[k] = remove_default_tags(v)
                    elif isinstance(v, list):
                        out[k] = []
                        for item in v:
                            if hasattr(item, '__keylist__'):
                                out[k].append(remove_default_tags(item))
                            else:
                                if item not in ('None', '', 'Default'):
                                    if item:
                                        out[k].append(item)
                    else:
                        out[k] = v
    return out

def recursive_asdict(d):
    """
    Convert Suds object into serializable format (dictonary).

    Requires: d -- the input suds object

    Returns:  out -- a dictionary representation od d
    """

    from suds.sudsobject import asdict

    out = {}
    for key, value in asdict(d).iteritems():
        if hasattr(value, '__keylist__'):
            out[key] = recursive_asdict(value)
        elif isinstance(value, list):
            out[key] = []
            for item in value:
                if hasattr(item, '__keylist__'):
                    out[key].append(recursive_asdict(item))
                else:
                    out[key].append(item)
        else:
            out[key] = value

    return out

    def ensure_instance(cls, model, the_data, allow_list=False, allow_none=False):
        if the_data is None and allow_none:
            return None

        if not isinstance(the_data, model):
            if isinstance(the_data, SudsObject):
                the_data = asdict(the_data)

            if isinstance(the_data, (list, tuple)):
                if not allow_list:
                    raise Exception('BaseDigidocServiceObject.ensure_instance: Lists not allowed in this context')

                result = []

                for item in the_data:
                    result.append(model.from_dict(item))

                return result

            elif isinstance(the_data, dict):
                return model.from_dict(the_data)

            else:
                raise Exception('BaseDigidocServiceObject.ensure_instance: The data must be one of: [cls, list, tuple, dict]')

        else:
            # It's an instance of the required class, all good
            return the_data

    def from_dict(cls, the_data):
        if isinstance(the_data, SudsObject):
            the_data = asdict(the_data)

        kwargs = BaseDigidocServiceObject.camel_2_py(the_data)

        return cls(**kwargs)

    def __new__(cls, *args, **kwargs):
        _apientity = None
        obj_type = None
        if 'TypeRecord' in kwargs:
            _apientity = kwargs.get('TypeRecord', None)
            _apientity_dict = asdict(_apientity)
            if len(_apientity_dict) == 0:
                return None
            obj_type = _apientity_dict.get('type', None)
            del kwargs['TypeRecord']
        kwargs['data'] = _apientity
        kwargs['data_dict'] = _apientity_dict
        if obj_type is not None:
            if obj_type.lower() == 'zone':
                return Zone(*args, **kwargs)
            if obj_type.lower() == 'configuration':
                return Configuration(*args, **kwargs)
            if obj_type.lower() == 'view':
                return View(*args, **kwargs)
            if obj_type.lower() == 'hostrecord':
                return HostRecord(*args, **kwargs)
            if obj_type.lower() == 'mxrecord':
                return MXRecord(*args, **kwargs)
            if obj_type.lower() == 'txtrecord':
                return TXTRecord(*args, **kwargs)
            if obj_type.lower() == 'aliasrecord':
                return CNAMERecord(*args, **kwargs)
            if obj_type.lower() == 'hinforecord':
                return HINFORecord(*args, **kwargs)
            if obj_type.lower() == 'srvrecord':
                return SRVRecord(*args, **kwargs)

        return None

def recursive_asdict(obj):
    """
    Convert Suds object into a dict so it can be serialized.
    Taken (mostly) from: http://stackoverflow.com/a/15678861

    @param obj, sudsobject: the suds object to be converted to dict
    @return dict: the object converted to a dict
    """
    # Don't convert a dict
    if isinstance(obj, dict):
        return obj

    out = {}
    for key, val in asdict(obj).iteritems():
        if hasattr(val, '__keylist__'):
            out[_underscore_key(key)] = recursive_asdict(val)
        elif isinstance(val, list):
            out[_underscore_key(key)] = []
            for item in val:
                if hasattr(item, '__keylist__'):
                    out[_underscore_key(key)].append(recursive_asdict(item))
                else:
                    out[_underscore_key(key)].append(to_string(item))
        else:
            out[_underscore_key(key)] = to_string(val)
    return out

    def register_account(self, registration):
        """Register a new account.

        :param registration: Registration instance.
        """
        arguments = asdict(registration)

        return self.call("RegisterAccount", **arguments)

 def load(self):
     super(HourlyDataIO, self).load()
     if self.data and 'values' in self.data[0]:
         self.data = [
             asdict(row)
             for row in as_list(self.data[0]['values'])
         ]
     else:
         raise NoData

 def dict(cls, sobject):
     """
     Convert a sudsobject into a dictionary.
     @param sobject: A suds object
     @type sobject: L{Object}
     @return: A python dictionary containing the
         items contained in I{sobject}.
     @rtype: dict
     """
     return sudsobject.asdict(sobject)

	def recursive_asdict(self,d):
		out = {}
		for k, v in asdict(d).iteritems():
			if hasattr(v, '__keylist__'):
				out[k] = self.recursive_asdict(v)
			elif isinstance(v, list):
				out[k] = []
				for item in v:
					if hasattr(item, '__keylist__'):
						out[k].append(self.recursive_asdict(item))
					else:
						out[k].append(item)
			else:
				out[k] = v
		return out

def resolve(res):
    if hasattr(res, '__keylist__'):
        ret = {}
        for k, v in asdict(res).iteritems():
            ret[k] = resolve(v)
        return ret
    elif isinstance(res, list):
        ret = []
        for i in res:
            ret.append(resolve(i))
        return ret
    elif isinstance(res, basestring):
        return res and unicode(res) or None
    else:
        return res

def recursive_asdict(data):
    """Convert Suds object into serializable format."""
    out = {}
    for key, val in asdict(data).iteritems():
        if hasattr(val, '__keylist__'):
            out[key] = recursive_asdict(val)
        elif isinstance(val, list):
            out[key] = []
            for item in val:
                if hasattr(item, '__keylist__'):
                    out[key].append(recursive_asdict(item))
                else:
                    out[key].append(item)
        else:
            out[key] = val
    return out