def authorize_doc(claveacceso, docstyle):
from suds.client import Client
import logging
logging.getLogger('suds.transport.http').setLevel(logging.INFO)
logging.info("Autorizando: %s" % (claveacceso))
ak = ""
try:
headers = {'Content-Type': 'application/soap+xml; charset="UTF-8"'}
client_aut = Client(C.authorization_url, headers=headers)
if docstyle == "comprobante":
response_aut = client_aut.service.autorizacionComprobante(claveacceso)
elif docstyle == "lote":
response_aut = client_aut.service.autorizacionComprobanteLoteMasivo(claveacceso)
res = sudsobject.asdict(response_aut)
if "claveAccesoConsultada" in res.keys():
ak = res["claveAccesoConsultada"]
if "autorizaciones" in res.keys():
aut = sudsobject.asdict(res["autorizaciones"])
if not aut:
raise ErisError("102", "La clave de acceso %s no tiene autorizaciones" % claveacceso)
return (ak, aut)
for authk, authv in res.items():
logging.info("k{}, v {}".format(authk, authv))
except Exception, e:
logging.exception(e)
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 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 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 unpack_suds_object(d):
"""Convert suds object into serializable format.
Transform suds object received from the DFP API into a Python dict.
Args:
d: A suds object.
Returns:
dict A serializable Python dict.
"""
out = {}
for key, value in asdict(d).iteritems():
if hasattr(value, '__keylist__'):
out[key] = unpack_suds_object(value)
elif isinstance(value, list):
out[key] = []
for item in value:
if hasattr(item, '__keylist__'):
out[key].append(unpack_suds_object(item))
else:
out[key].append(item)
else:
out[key] = value
return out
def _suds_to_dict(self, sud_obj):
if hasattr(sud_obj, '__keylist__'):
sud_dict = asdict(sud_obj)
new_dict = {}
for key in sud_dict:
new_dict[key] = self._suds_to_dict(sud_dict[key])
return new_dict
elif isinstance(sud_obj, list):
new_list = []
for elm in sud_obj:
new_list.append(self._suds_to_dict(elm))
return new_list
elif isinstance(sud_obj, datetime):
try:
return sud_obj.strftime("%Y-%m-%dT%H:%M:%S%z")
except ValueError:
return None
# Checking for NaN
elif sud_obj != sud_obj:
return None
return sud_obj
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 asdict(cls, suds_object: sudsobject.Object) -> Mapping[str, Any]:
"""
Converts nested Suds Object into serializable format.
Input sample:
{
obj[] =
{
value = 1
},
{
value = "str"
},
}
Output sample: =>
{'obj': [{'value': 1}, {'value': 'str'}]}
"""
result: Mapping[str, Any] = {}
for field, val in sudsobject.asdict(suds_object).items():
if hasattr(val, "__keylist__"):
result[field] = cls.asdict(val)
elif isinstance(val, list):
result[field] = []
for item in val:
if hasattr(item, "__keylist__"):
result[field].append(cls.asdict(item))
else:
result[field].append(item)
elif isinstance(val, datetime):
result[field] = val.isoformat()
else:
result[field] = val
return result
def recursive_asdict(d):
"""
Convert Suds object into serializable format (dictonary).
Requires: d -- the input suds object
Returns: out -- a dictionary representation of d
"""
from suds.sudsobject import asdict
out = {}
for key, value in asdict(d).items():
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 serialize_soap_resp(resp):
"""
Convert Adwords SOAP response to serializable dict
:param resp: SOAP response
:return: Dictionary representation of response
"""
out = {}
for k, v in asdict(resp).iteritems():
if hasattr(v, '__keylist__'):
out[k] = serialize_soap_resp(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(serialize_soap_resp(item))
else:
out[k].append(item)
else:
try:
out[k] = v.encode('utf-8')
except AttributeError:
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 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(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 __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(self,d):
"""
Helper function to make Suds object into serializable format recurvesively . It is used in the _parseJSON and _parseWML functions.
Args:
d: json object
Returns:
None
"""
out = {}
try:
for k, v in asdict(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)
else:
out[k] = v
except AssertionError as error:
print("The following Suds Object cannot be converted to serializable object", error)
return out
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 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 register_account(self, registration):
"""Register a new account.
:param registration: Registration instance.
"""
arguments = asdict(registration)
return self.call("RegisterAccount", **arguments)
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 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 load(self):
super(HourlyDataIO, self).load()
d = {
} # since mutiple triplets can be used, then go through each station
for data in self.data:
stationTriplet = data['stationTriplet']
if data and 'values' in data:
data = [asdict(row) for row in as_list(data['values'])]
else:
data = []
d[stationTriplet] = data
self.data = d
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 __convertSudsToDict(self, sudsResponse):
out = {}
for k, v in asdict(sudsResponse).iteritems():
if hasattr(v, '__keylist__'):
out[k] = self.__convertSudsToDict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(self.__convertSudsToDict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def __recursive_dict(self, d):
out = {}
for k, v in asdict(d).items():
if hasattr(v, '__keylist__'):
out[k] = self.__recursive_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(self.__recursive_dict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_translation(d):
result = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
result[k] = recursive_translation(v)
elif isinstance(v, list):
result[k] = []
for item in v:
if hasattr(item, '__keylist__'):
result[k].append(recursive_translation(item))
else:
result[k].append(item)
else:
result[k] = v
return result
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 traduccion_recursiva(d):
result = {}
for k, v in asdict(d).items():
if hasattr(v, '__keylist__'):
result[k] = traduccion_recursiva(v)
elif isinstance(v, list):
result[k] = []
for item in v:
if hasattr(item, '__keylist__'):
result[k].append(traduccion_recursiva(item))
else:
result[k].append(item)
else:
result[k] = v
return result
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
def __suds_to_dict(self, data):
"""Converte sudsobject para dict"""
out = {}
for key, value in list(asdict(data).items()):
if hasattr(value, '__keylist__'):
out[key] = self.__suds_to_dict(value)
elif isinstance(value, list):
out[key] = []
for item in value:
if hasattr(item, '__keylist__'):
out[key].append(self.__suds_to_dict(item))
else:
out[key].append(item)
else:
out[key] = value
return out
def _suds2dict(suds_instance):
from suds.sudsobject import asdict
out = {'__class__': suds_instance.__class__.__name__}
for k, v in asdict(suds_instance).items():
if hasattr(v, '__keylist__'):
out[k] = _suds2dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(_suds2dict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""From http://stackoverflow.com/a/15678861"""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""Convert Suds object into serializable format."""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""From http://stackoverflow.com/a/15678861"""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""Convert Suds object into serializable format."""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def to_dict(sudsobject):
d = sudsobject
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = to_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(to_dict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(suds_data):
''' Convert Suds object into serializable format. '''
out = {}
for key, value in asdict(suds_data).items():
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 sobject_to_dict(obj):
if not hasattr(obj, '__keylist__'):
return obj
out = {}
for key, value in asdict(obj).items():
if hasattr(value, '__keylist__'):
out[key] = sobject_to_dict(value)
elif isinstance(value, list):
out[key] = []
for item in value:
out[key].append(sobject_to_dict(item))
elif isinstance(value, datetime):
out[key] = arrow.get(value).isoformat()
else:
out[key] = value
return out
def recursive_dict(self, response):
out = {}
for k, v in asdict(response).iteritems():
if hasattr(v, '__keylist__'):
out[k] = self.recursive_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(self.recursive_dict(item))
else:
out[k].append(item)
elif isinstance(v, suds.sax.text.Text):
out[k] = str(v)
else:
out[k] = v
return out
def convert_to_hash(self, d):
"""Convert Suds object into serializable format."""
out = {}
for k, v in asdict(d).items():
if type(v) is datetime:
v = str(v)
if hasattr(v, '__keylist__'):
out[k] = self.convert_to_hash(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(self.convert_to_hash(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""
Recursively convert Suds object into dict.
We convert the keys to lowercase, and convert sax.Text
instances to Unicode.
Taken from:
http://stackoverflow.com/a/15678861/202168
Let's create a suds object from scratch with some lists and stuff
>>> from suds.sudsobject import Object as SudsObject
>>> sudsobject = SudsObject()
>>> sudsobject.Title = "My title"
>>> sudsobject.JustAList = [1, 2, 3]
>>> sudsobject.Child = SudsObject()
>>> sudsobject.Child.Title = "Child title"
>>> sudsobject.Child.AnotherList = ["4", "5", "6"]
>>> childobject = SudsObject()
>>> childobject.Title = "Another child title"
>>> sudsobject.Child.SudObjectList = [childobject]
Now see if this works:
>>> result = recursive_asdict(sudsobject)
>>> result['title']
'My title'
>>> result['child']['anotherlist']
['4', '5', '6']
"""
out = {}
for k, v in asdict(d).items():
k = k.lower()
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(
item.title() if isinstance(item, Text) else item)
else:
out[k] = v.title() if isinstance(v, Text) else v
return out
def soap_recursive_dict(d):
"""
recursively serializes a soap dictionary in to
a pure python dictionary.
"""
out = {}
for k, v in list(asdict(d).items()):
if hasattr(v, '__keylist__'):
out[k] = soap_recursive_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(soap_recursive_dict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def nice_response(d):
out = {}
for k, v in asdict(d).items():
if k != '_uuid':
if hasattr(v, '__keylist__'):
if hasattr(v, 'value'):
out[k] = v.value
else:
out[k] = nice_response(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(nice_response(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def _recursive_asdict(self, suds_object):
"""As suds response is an special object, we convert it into
a more usable python dict. Taken form:
https://stackoverflow.com/a/15678861
"""
out = {}
for k, v in asdict(suds_object).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)
else:
out[k] = v
return out
def soap_recursive_dict(d):
"""
recursively serializes a soap dictionary in to
a pure python dictionary.
"""
out = {}
for k, v in asdict(d).items():
if hasattr(v, '__keylist__'):
out[k] = soap_recursive_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(soap_recursive_dict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""
Convert Suds object into serializable format, so it can be cached.
From https://gist.github.com/robcowie/a6a56cf5b17a86fdf461
"""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def wsdl_create_factory(self, name, **kargs):
params = self.suds.factory.create(name)
# e.g., for eutils
if "email" in dict(params).keys():
params.email = self.settings.params['user.email'][0]
if "tool" in dict(params).keys():
import bioservices
params.tool = "BioServices, " + bioservices.__version__
for k,v in kargs.items():
from suds import sudsobject
keys = sudsobject.asdict(params).keys()
if k in keys:
params[k] = v
else:
msg = "{0} incorrect. Correct ones are {1}"
self.logging.error(msg.format(k, keys))
return params
def suds_response_to_dict(d): # pragma: no cover
"""
Convert Suds object into serializable format.
Source: http://stackoverflow.com/a/15678861/592820
"""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = suds_response_to_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(suds_response_to_dict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
"""
Recursively convert Suds object into dict.
http://stackoverflow.com/a/15678861/202168
"""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
out[k].append(item)
else:
out[k] = v
return out
def recursive_asdict(d):
from suds.sudsobject import asdict
from suds.sax.text import Text
"""Convert Suds object into serializable format."""
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = recursive_asdict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(recursive_asdict(item))
else:
if isinstance(item, Text):
item = str(item)
out[k].append(item)
else:
if isinstance(v, Text):
v = str(v)
out[k] = v
return out
def getAFMinfo(self, called_for, called_by):
"""Retrieve full VAT-number info
@param called_for VAT number to look up in service
@param called_by VAT number of the user requesting information. It will
just be logged in the remote servers as a legal requirement
@return ??
"""
from suds import null
from suds.sudsobject import asdict
def _reset(obj):
""" Resets all attributes of a suds.Object to null values
The default pythonic `None` value would cause them to be
skipped, not sent.
"""
for k in obj.__keylist__:
obj[k] = null()
qry = self._client.factory.create('RgWsPublicInputRtUser')
r2 = self._client.factory.create('RgWsPublicBasicRtUser')
#out1 = client.factory.create('RgWsPublicFirmActRtUserArray')
err = self._client.factory.create('GenWsErrorRtUser')
qry.afmCalledBy = compact(called_by)
qry.afmCalledFor= compact(called_for)
_reset(r2)
_reset(err)
ret = self._client.service.rgWsPublicAfmMethod(qry,r2,'',0, err)
if ret.pErrorRec_out and ret.pErrorRec_out.errorCode:
raise CheckException(ret.pErrorRec_out.errorCode, ret.pErrorRec_out.errorDescr)
else:
return asdict(ret)
def recursive_asdict(self, d):
"""Convert Suds object into serializable format."""
out = {}
for k, v in asdict(d).iteritems():
k = k.replace('.', '')
k = k[0].lower() + k[1:]
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:
try:
out[k] = v.encode('utf-8')
except AttributeError:
out[k] = v
return out
def suds_to_dict(d):
"""Convert Suds object into serializable format."""
if isinstance(d, list):
return [suds_to_dict(d2) for d2 in d]
else:
out = {}
for k, v in asdict(d).iteritems():
if hasattr(v, '__keylist__'):
out[k] = suds_to_dict(v)
elif isinstance(v, list):
out[k] = []
for item in v:
if hasattr(item, '__keylist__'):
out[k].append(suds_to_dict(item))
else:
out[k].append(item)
elif isinstance(v, Decimal) or isinstance(v, date):
out[k] = str(v)
else:
out[k] = v
return out
