def connect_soap(self, wsdl, model): if 'company_id' in model._fields: public_crt, private_key = self.env[ 'l10n.es.aeat.certificate'].get_certificates(model.company_id) else: public_crt, private_key = self.env[ 'l10n.es.aeat.certificate'].get_certificates() session = Session() session.cert = (public_crt, private_key) transport = Transport(session=session) history = HistoryPlugin() client = Client(wsdl=wsdl, transport=transport, plugins=[history]) return client
def update_soap_record(self, soap_object, data): session = Session() session.auth = HTTPBasicAuth(self.nav_user, self.nav_password) soap_service_url = self.nav_soap_service + \ self.nav_company + '/Page/' + soap_object client = Client(soap_service_url, transport=Transport(session=session, cache=SqliteCache())) complex_type = client.get_type(f'ns0:{soap_object}') record = complex_type(**data) serialized_response = client.service.Update(record) return serialized_response
def SOAP_runJob(self, context, jobunitId, jobId, jobWM=1, jobWT=1): HM = data_model.Hinemos.create_from_context(context) csapisession = CloudShellAPISession( host=context.connectivity.server_address, token_id=context.connectivity.admin_auth_token, domain=context.reservation.domain) ip = context.resource.address username = HM.user password = csapisession.DecryptPassword( context.resource.attributes['Hinemos.Password']).Value #with CloudShellSessionContext(context) as session: #session.WriteMessageToReservationOutput(context.reservation.reservation_id, 'Password found : {}'.format(password)) session = Session() session.auth = HTTPBasicAuth(username, password) client = Client("http://" + ip + ":8080/HinemosWS/JobEndpoint?wsdl", transport=Transport(session=session)) factory = client.type_factory( 'http://jobmanagement.ws.clustercontrol.com') out = factory.outputBasicInfo() trig = factory.jobTriggerInfo() trig.trigger_type = 2 trig.trigger_info = username out.priority = 0 trig.jobCommand = "" trig.jobWaitMinute = jobWM trig.jobWaitTime = jobWT session_id = client.service.runJob(jobunitId, jobId, out, trig) with CloudShellSessionContext(context) as session: session.WriteMessageToReservationOutput( context.reservation.reservation_id, "Hinemos Runjob:") session.WriteMessageToReservationOutput( context.reservation.reservation_id, "-Inputs: JobUnitId=" + jobunitId + " JobId=" + jobId) session.WriteMessageToReservationOutput( context.reservation.reservation_id, '-RunJob Output (Session ID) = {}'.format(session_id)) pass
def __init__(self, server="", provider="", username="", password="", version=""): # TODO: add checks # for key, value in locals().items(): # if value is "": # raise ValueError('Argument %s required', key) super(BaseProvisioningService, self).__init__() self.server = server self._add_scheme_to_server() self.provider = provider self.username = username self.password = password self.version = version self.endpoint = self._build_endpoint_from_server() self.wsdl = self._build_wsdl_url_from_endpoint() self.userpath = self._build_full_username() # plugin for fixing the arrays arrayfixer = ArrayFixer() booleanfixer = BooleanFixer() # initialize our client using basic auth and with the wsdl file session = Session() session.auth = HTTPBasicAuth(self.userpath, self.password) settings = Settings( strict=False, # ePages wsdl files are full of errors... ) client = Client(wsdl=self.wsdl, settings=settings, transport=Transport(session=session), plugins=[arrayfixer, booleanfixer]) self.client = client # get the binding name, there is only one so this should be ok qname = next(iter(client.wsdl.bindings)) # and create new service with the name pointing to our endpoint self.service2 = client.create_service(qname, self.endpoint) logger.debug('Initialized new client: %s', self.client)
def connect_to_cucm(username=None, password=None, cucm_ip=None): WSDL_FILE = str(Path('schema') / 'AXLAPI.wsdl') DEBUG = False SUPRESS_INSECURE_CONNECTION_WARNINGS = True if SUPRESS_INSECURE_CONNECTION_WARNINGS: import urllib3 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # This class lets you view the incoming and outgoing http headers and/or XML class MyLoggingPlugin(Plugin): def egress(self, envelope, http_headers, operation, binding_options): xml = etree.tostring(envelope, pretty_print=True, encoding='unicode') print( f'\nRequest\n-------\nHeaders:\n{http_headers}\n\nBody:\n{xml}' ) def ingress(self, envelope, http_headers, operation): xml = etree.tostring(envelope, pretty_print=True, encoding='unicode') print( f'\nResponse\n-------\nHeaders:\n{http_headers}\n\nBody:\n{xml}' ) sess = Session() sess.verify = False sess.auth = HTTPBasicAuth(username, password) transport = Transport(session=sess, timeout=10) settings = Settings(strict=False, xml_huge_tree=True) plugin = [MyLoggingPlugin()] if DEBUG else [] client = Client(WSDL_FILE, settings=settings, transport=transport, plugins=plugin) service = client.create_service( '{http://www.cisco.com/AXLAPIService/}AXLAPIBinding', 'https://{cucm}:8443/axl/'.format(cucm=cucm_ip)) return service
def authenticate(self, key, verify=True): """Authenticates client Note ---- This method additionaly sets sid (session id) header in Client's Session object. There is no need to set it manually. This method additionaly sets 'key' attribute This method additionaly sets 'sid' attribute Parameters ---------- key : str API key verify : bool If True verifies if authentication was successfull Returns ------- str sid (session id) required by API for further requests. Raises ------ ApiAuthenticationError If authentication was a failure """ if not self.is_production: key = API_KEY_TEST_ENV logger.debug('key=%s verify=%s' % (key, verify)) sid = self.service.Zaloguj(key) session = Session() session.headers.update({'sid': sid}) self.client = Client(wsdl=self.wsdl, transport=Transport(session=session)) self._create_service() if verify: if not self._check_session(): logger.error('Authentication failed') raise ApiAuthenticationError(key) else: logger.debug('Authenticated successfully') self.key = key self.sid = sid return sid
def __init__(self, xml_string="", site_file=None, site_id_column_header='site_id', testing=False, endpoint=SCHEDULE_ENDPOINT): """ Initializes the ScheduleConnection. This method attempts to authenticate the connection, pulls site_ids from the site_id file, and determines WSDL definition info :param xml_string: override the default xml, which is just <tangier method="schedule.request"/> :param site_file: (str) fully qualified path to xlsx or csv document containing all tangier site ids :param site_id_column_header: (str) header name of column containing site ids in site_file :param endpoint: where the WSDL info is with routing info and SOAP API definitions """ super(self.__class__, self).__init__() if not xml_string: self.base_xml = """<tangier version="1.0" method="schedule.request"></tangier>""" else: self.base_xml = xml_string if site_file: if site_file.endswith('.xlsx'): df = pandas.read_excel(site_file) elif site_file.endswith('.csv'): df = pandas.read_csv(site_file) else: df = pandas.DataFrame() print( 'Did not read site file; must be a csv or xlsx document.') if not df.empty and site_id_column_header in list(df.columns): if testing: self.site_ids = list( numpy.random.choice(df[site_id_column_header], 20, replace=False)) else: self.site_ids = list(df[site_id_column_header]) elif df.emtpy: self.site_ids = [] else: print('Site ids must be in a column with the header "{0}"'. format(site_id_column_header)) self.base_xml = xmlmanip.inject_tags(self.base_xml, user_name=TANGIER_USERNAME, user_pwd=TANGIER_PASSWORD) self.client = Client(endpoint, transport=Transport(session=Session())) self.saved_schedule = None
def main(): path = Path('C:\\shared\\API\\credentials') wsdl = 'file://C://shared//API//axlsqltoolkit//schema//11.5//AXLAPI.wsdl' platform = 'CUCM' role = 'rwx' urllib3.disable_warnings(InsecureRequestWarning) server = path / REGION / platform / ('fqdn' + '.txt') binding_name = '{http://www.cisco.com/AXLAPIService/}AXLAPIBinding' address = 'https://{fqdn}:8443/axl/'.format(fqdn=read(server)[0]) session = Session() session.verify = False session.auth = HTTPBasicAuth( read(file(path, platform, role)[0])[0], crypto(file(path, platform, role)[1], file(path, platform, role)[2])) transport = Transport(cache=SqliteCache(), session=session, timeout=60) client = Client(wsdl=wsdl, transport=transport) axl = client.create_service(binding_name, address) language = mylocale(axl) for para in readCSV(FILE): udplist = myvariables(axl, para['user']) udplist['udplist'].append(para['udp']) delLine( axl, para['dirn'], para['dnpt'], ) addLine( axl, para['dirn'], para['desc'], 'Device', para['dnpt'], para['llabel'], ) addUDP(axl, para['udp'], para['model'], para['desc'], para['ptn'], para['local'], para['dirn'], para['dnpt'], para['llabel'], para['ldisplay']) updateUser(axl, para['user'], language[para['language'].upper()], udplist['udplist']) print("\n")
def _l10n_mx_edi_finkok_cancel(self, pac_info): '''CANCEL for Finkok. ''' url = pac_info['url'] username = pac_info['username'] password = pac_info['password'] for inv in self: uuid = inv.l10n_mx_edi_cfdi_uuid certificate_ids = inv.company_id.l10n_mx_edi_certificate_ids certificate_id = certificate_ids.sudo().get_valid_certificate() company_id = self.company_id cer_pem = certificate_id.get_pem_cer(certificate_id.content) key_pem = certificate_id.get_pem_key(certificate_id.key, certificate_id.password) cancelled = False code = False try: transport = Transport(timeout=20) client = Client(url, transport=transport) # uuid_type = client.get_type('ns0:stringArray')() # uuid_type.string = [uuid] # invoices_list = client.get_type('ns1:UUIDS')(uuid_type) ########### uuid_type = client.get_type('ns1:UUID')() uuid_type.UUID = uuid uuid_type.FolioSustitucion = inv.replace_folio or '' if not inv.edi_cancel_reason_id: raise UserError("reason not defined") uuid_type.Motivo = inv.edi_cancel_reason_id.code invoices_list = client.get_type('ns1:UUIDS')(uuid_type) ############# response = client.service.cancel(invoices_list, username, password, company_id.vat, cer_pem, key_pem) except Exception as e: inv.l10n_mx_edi_log_error(str(e)) continue if not (hasattr(response, 'Folios') and response.Folios): msg = _( 'A delay of 2 hours has to be respected before to cancel') else: code = getattr(response.Folios.Folio[0], 'EstatusUUID', None) cancelled = code in ('201', '202' ) # cancelled or previously cancelled # no show code and response message if cancel was success code = '' if cancelled else code msg = '' if cancelled else _("Cancelling got an error") inv._l10n_mx_edi_post_cancel_process(cancelled, code, msg)
def setLrApiClient(url, username, password): """Creates and set LogRythem API Client Args: url: string LogRythem API server url username: string LogRythem API username password: string LogRythem API password Return: apiClient: object """ session = Session() session.verify = False transport = Transport(session=session, timeout=120) apiClient = Client(url, wsse=UsernameToken(username, password), transport=transport, strict=False) return apiClient
def __init__(self, wsdl, wsse=None, transport=None, service_name=None, port_name=None): if not wsdl: raise ValueError("No URL given for the wsdl") self.transport = transport or Transport() self.wsdl = Document(wsdl, self.transport) self.wsse = wsse self._default_service = None self._default_service_name = service_name self._default_port_name = port_name
def __init__(self, username, password, server_ip, tls_verify=True): wsdl = 'https://{0}:8443/controlcenterservice2/services/ControlCenterServices?wsdl'.format( server_ip) self.session = Session() self.session.auth = HTTPBasicAuth(username, password) self.session.verify = tls_verify self.cache = SqliteCache(path='/tmp/sqlite_serviceability.db', timeout=60) self.client = Client(wsdl=wsdl, transport=Transport(cache=self.cache, session=self.session)) self.service = self.client.service
def get_soap_data(msg_request): session = Session() session.auth = HTTPBasicAuth(username=login, password=password) cnn_settings = Settings(strict=True, xml_huge_tree=True) client = Client(wsdl=cnn_url, transport=Transport(session=session), settings=cnn_settings) with client.settings(strict=False, raw_response=True, xml_huge_tree=True): saop_data = client.service[serviceName](**msg_request) # print saop_data # print saop_data.content return saop_data.content
def create_client(self): session = Session() session.verify = False try: transport = Transport(cache=SqliteCache(), session=session) history = HistoryPlugin() client = Client(self.soap_url, transport=transport, plugins=[history]) if client: print("client: {}".format(client)) return client, history else: raise AccessError(_("Not possible to establish a client.")) except Exception as e: raise AccessError(_("Access error message: {}".format(e)))
def axl_bind(server, acct, pw): binding_name = "{http://www.cisco.com/AXLAPIService/}AXLAPIBinding" axl_address = "https://{}:8443/axl/".format(server) script_dir = os.path.dirname(__file__) wsdl_file = "{}\\AXLAPI.wsdl".format(script_dir) session = Session() session.verify = False session.auth = HTTPBasicAuth(acct, pw) transport = Transport(session=session, timeout=20) history = HistoryPlugin() settings = Settings(strict=False, xml_huge_tree=True) client = Client(wsdl=wsdl_file, transport=transport, plugins=[history], settings=settings) axl = client.create_service(binding_name, axl_address) return axl, history
def __init__(self, server, username="", password="", debug=False): """At minimum server address or IP must be provided service = OPDMservice(<server_ip_or_address>)""" wsdl = '{}/cxf/OPDMSoapInterface?wsdl'.format(server) session = Session() session.verify = False session.auth = HTTPBasicAuth(username, password) transport = Transport(session=session) client = Client(wsdl, transport=transport) client.debug = debug self.client = client self.API_VERSION = "0.2"
def __init__(self, shopping_list_path, LatestFlag="Y", proxies=None): self.LatestFlag = LatestFlag self.proxies = proxies self.shopping_list_path = shopping_list_path self.shopping_list = pd.read_excel(shopping_list_path) # create session to accomodate proxies session = Session() session.proxies = self.proxies retry = Retry(connect=3, backoff_factor=0.5) adapter = HTTPAdapter(max_retries=retry) session.mount("http://", adapter) session.mount("https://", adapter) url = "http://marketinformation.natgrid.co.uk/MIPIws-public/public/publicwebservice.asmx?wsdl" self.client = Client(url, transport=Transport(session=session))
def getClient(servicewsdl): """Attempt to stablish a connection to the webservice and return a client object connected to servicewsdl webservice""" client = None try: webSession = WebSession() webSession.auth = HTTPBasicAuth('soap', "") transport = Transport(timeout=10, session = webSession) client = zeep.Client(wsdl=servicewsdl, transport=transport) print('Client successfully created') except Exception as e: print(traceback.format_exc()) print("error in getting a client to the webservice") return client
def __init__(self, *args, **kwargs): self.cert = kwargs.get('cert', self.cert) self.ca_cert = kwargs.get('ca_cert', self.ca_cert) self.key = kwargs.get('key', self.key) self.company = kwargs.get('company', self.company) self.username = kwargs.get('username', self.username) self.timeout = kwargs.get('timeout', self.timeout) session = Session() if self.cert and self.key and self.ca_cert: session.cert = (self.cert, self.key) session.verify = self.ca_cert elif self.cert or self.key or self.ca_cert: raise ValueError("Must provide cert, ca_cert and key") self.client = Client(self.endpoint, transport=Transport(session=session, timeout=self.timeout))
def _initSoapClient(self, logTag: str) -> Client: self.tracer.info("%s begin initialize SOAP client for wsdl: %s", logTag, self.wsdlUrl) startTime = time() client = None try: session = Session() session.verify = False client = Client(self.wsdlUrl, transport=Transport(session=session, timeout=SOAP_API_TIMEOUT_SECS, operation_timeout=SOAP_API_TIMEOUT_SECS)) self.tracer.info("%s initialize SOAP client SUCCESS for wsdl: %s [%d ms]", logTag, self.wsdlUrl, TimeUtils.getElapsedMilliseconds(startTime)) return client except Exception as e: self.tracer.error("%s initialize SOAP client ERROR for wsdl: %s [%d ms] %s", logTag, self.wsdlUrl, TimeUtils.getElapsedMilliseconds(startTime), e, exc_info=True) raise e
def test_parse_soap_header_wsdl(): client = Client("tests/wsdl_files/soap_header.wsdl", transport=Transport()) response = """ <?xml version="1.0"?> <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:stoc="http://example.com/stockquote.xsd"> <soapenv:Header/> <soapenv:Body> <stoc:TradePrice> <price>120.123</price> </stoc:TradePrice> </soapenv:Body> </soapenv:Envelope> """.strip() with requests_mock.mock() as m: m.post("http://example.com/stockquote", text=response) result = client.service.GetLastTradePrice( tickerSymbol="foobar", _soapheaders={"header": {"username": "******", "password": "******"}}, ) assert result.body.price == 120.123 assert result.header.body is None request = m.request_history[0] # Compare request body expected = """ <soap-env:Envelope xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"> <soap-env:Header> <ns0:Authentication xmlns:ns0="http://example.com/stockquote.xsd"> <username>ikke</username> <password>oeh-is-geheim!</password> </ns0:Authentication> </soap-env:Header> <soap-env:Body> <ns0:TradePriceRequest xmlns:ns0="http://example.com/stockquote.xsd"> <tickerSymbol>foobar</tickerSymbol> </ns0:TradePriceRequest> </soap-env:Body> </soap-env:Envelope> """ assert_nodes_equal(expected, request.body)
def main(): module = AnsibleModule(argument_spec=dict(username=dict(required=True), password=dict(required=True), description=dict(required=True), agent=dict(required=True), path=dict(required=True, type='path')), supports_check_mode=True) agent = module.params.get('agent') description = module.params.get('description') path = module.params.get('path') username = module.params.get('username') password = module.params.get('password') http_auth = HTTPBasicAuth(username, password) transport = Transport(http_auth=http_auth) client = Client('http://localhost:9080/DiskSafe?wsdl', transport=transport) # Lookup the agent by hostname agent = _get_agent(transport, agent) if agent is None: module.fail_json(msg='Agent missing from server') # Lookup the disk safe disk_safe = _get_disk_safe(client, description) if disk_safe: module.exit_json(changed=False) # Not check mode, create the disk safe if not module.check_mode: disk_safe = { 'description': description, 'path': path, 'compressionType': 'QUICKLZ', 'deviceBackupType': 'AUTO_ADD_DEVICES', 'backupPartitionTable': True, 'agentID': agent['id'] } try: client.service.createDiskSafeWithObject(disksafe=disk_safe) except (Fault, ValueError) as ex: module.fail_json(msg=ex.message) # New volume created! module.exit_json(changed=True)
def __init__(self, account=None, caching=True, caching_timeout=2592000): """ Initialize the Zeep SOAP client, parse the xsd specifications of Netsuite and store the complex types as attributes of this instance. :param str account_id: Account ID to connect to :param str caching: If caching = 'sqlite', setup Sqlite caching :param int caching_timeout: Timeout in seconds for caching. If None, defaults to 30 days """ self.logger = logging.getLogger(self.__class__.__name__) assert account, 'Invalid account' assert '-' not in account, 'Account cannot have hyphens, it is likely an underscore' self._account = account self._wsdl_url = self.WSDL_URL_TEMPLATE.format( account=account.replace('_', '-')) self._datacenter_url = self.DATACENTER_URL_TEMPLATE.format( account=account.replace('_', '-')) if caching: path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'cache.db') timeout = caching_timeout cache = SqliteCache(path=path, timeout=timeout) transport = Transport(cache=cache) else: transport = None # Initialize the Zeep Client self._client = Client(self._wsdl_url, transport=transport) # default service points to wrong data center. need to create a new service proxy and replace the default one self._service_proxy = self._client.create_service( '{urn:platform_2020_1.webservices.netsuite.com}NetSuiteBinding', self._datacenter_url) # Parse all complex types specified in :const:`~netsuitesdk.netsuite_types.COMPLEX_TYPES` # and store them as attributes of this instance. Same for simple types. self._namespaces = {} self._init_complex_types() self._init_simple_types() self._app_info = None self._is_authenticated = False self.set_search_preferences()
def __init__(self, username, password, realm, log_file, test_login=True): super().__init__(realm) transport = Transport(timeout=1000) self.client = Client(self.NIF_PAYMENT_URL, wsse=UsernameToken(username, password), plugins=[LoggingPlugin(log_file)], transport=transport) self.ns5 = self.client.type_factory('ns5') if test_login is True: state, result = self._test() if state is not True: raise NIFApiAuthenticationError( 'Could not authenticate via test')
def _connect(self, url): transport_session = requests.Session() transport_session.mount( 'https://', CustomHTTPSAdapter( ctx_options={ 'cert': self.cert_data['cert'], 'key': self.cert_data['key'], 'cafile': self.ca_file } ) ) ws_transport = Transport(session=transport_session) return Client( url, transport=ws_transport )
def get_policy_details_host(): # SOAP call to get policy details per host hosts = get_all_hosts() session = Session() session.verify = False transport = Transport(session=session) client = Client('https://' + DS_host + ':4119/webservice/Manager?WSDL', transport=transport) sid = client.service.authenticate(username, password) for host in hosts: securityProfileID = host['securityProfileID'] if securityProfileID == None: continue else: hosts = client.service.securityProfileRetrieve( securityProfileID, sid) print(hosts)
def __init__(self, server, username="", password="", debug=False): """At minimum server address or IP must be provided""" wsdl = '{}/ws/madesInWSInterface.wsdl'.format(server) session = Session() session.verify = False session.auth = HTTPBasicAuth(username, password) transport = Transport(session=session) client = Client(wsdl, transport=transport) client.debug = debug self.service = client.create_service( '{http://mades.entsoe.eu/}MadesEndpointSOAP12', '{}/ws/madesInWSInterface'.format(server))
def ws_support_register(email, title, mes): urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) session = Session() session.verify = False transport = Transport(session=session) client = Client("http://support.robokassa.ru/svc/support.asmx?WSDL", transport=transport) RegisterRequest = { 'EMail': email, 'Title': title, 'Message': mes, "RequestID": 2000000, 'PersonID': str(uuid.uuid4()) } # print(RegisterRequest['PersonID']) result = client.service.Register(request=RegisterRequest) return result
def consumo_servicio(): # Se envia la url y las credenciales como parametro para crear el cliente del servicio wsd = 'https://facturaelectronica.dian.gov.co/operacion/B2BIntegrationEngine/FacturaElectronica/consultaDocumentos.wsdl' transport = Transport(timeout=10) user = '******' passwd = '7ea182d7fe1b9359812828166500793077c6d6f16ded5f8516159bc1b9fdf7e7' client = Client(wsdl=wsd, wsse=UsernameToken(user, passwd), transport=transport) # Se declara la fabrica para que el WS reciba los datos correctamente with open('info_facturas.txt', 'r') as info_facturas: for line in info_facturas.readlines(): line_temp = line.split(",") strformat = "%Y-%m-%dT%H:%M:%S" id_fac = line_temp[0] fecha_fac = datetime.datetime.strptime(line_temp[1], strformat) nit_fac = line_temp[2] cufe_fac = line_temp[3].rstrip() factory = client.type_factory('ns0') date = fecha_fac tipoDoc = factory.TipoDocumenotoType('1') num_doc = factory.NumeroDocumentoType(id_fac) nit = factory.NitType(nit_fac) id_software = factory.IdentificadorSoftwareType( '5ac5e351-ed30-4e8c-90ff-d56d1ba91dbe') cufe = factory.CufeType(cufe_fac) # Se configura el cliente para consumir el servicio with client.settings(strict=False, xml_huge_tree=False, raw_response=True): operation = client.service.ConsultaResultadoValidacionDocumentos( tipoDoc, num_doc, nit, date, id_software, cufe) operation_code = operation correct_res = correct_document(operation._content) with open('result.xml', 'w') as fileobj: fileobj.write(str(correct_res)) fileobj.close() Parse_Document.parse_document(correct_res, operation_code.status_code, id_fac) info_facturas.close()
def get_wsdl_service(self, wsdl_path): domain = current_app.config['SF_DOMAIN'] + '.salesforce.com' wsdl = 'https://{}{}'.format(domain, wsdl_path) if not hasattr(self, wsdl_path): # Add cookie `sid` to get WSDL sid = self.sf.session_id self.sf.session.cookies['sid'] = sid client = Client(wsdl, transport=Transport(session=self.sf.session)) # Add SessionHeader for accessing the service client.set_default_soapheaders({'SessionHeader': sid}) setattr(self, wsdl_path, client) self.WSDL_METHODS.add(wsdl_path) return getattr(self, wsdl_path).service