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 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 __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 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 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 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