def _setup_connection(): # Setup SOAP/AXL/HTTPS Connection global service # Change to true to enable output of request/response headers and XML DEBUG = False # The WSDL is a local file in the working directory, see README WSDL_FILE = 'schema/AXLAPI.wsdl' # This class lets you view the incoming and outgoing http headers and XML class MyLoggingPlugin(Plugin): def egress(self, envelope, http_headers, operation, binding_options): # Format the request body as pretty printed XML 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): # Format the response body as pretty printed XML xml = etree.tostring(envelope, pretty_print=True, encoding='unicode') print(f'\nResponse\n-------\nHeaders:\n{http_headers}\n\nBody:\n{xml}') # The first step is to create a SOAP client session session = Session() # We avoid certificate verification by default # session.verify = False # To enabled SSL cert checking (recommended for production) # place the CUCM Tomcat cert .pem file in the root of the project # and uncomment the line below session.verify = sessionCert # Add Basic Auth credentials session.auth = HTTPBasicAuth(cucmusername, cucmpassword) # Create a Zeep transport and set a reasonable timeout value transport = Transport(session=session, timeout=10) # strict=False is not always necessary, but it allows zeep to parse imperfect XML settings = Settings(strict=False, xml_huge_tree=True) # If debug output is requested, add the MyLoggingPlugin callback plugin = [MyLoggingPlugin()] if DEBUG else [ ] # Create the Zeep client with the specified settings client = Client(WSDL_FILE, settings=settings, transport=transport, plugins=plugin) # FUTURE create CUCM chooser menu # Create the Zeep service binding to AXL at the specified CUCM service = client.create_service('{http://www.cisco.com/AXLAPIService/}AXLAPIBinding', serverUrl)
def __init__(self, url, username, password): self.IdToPropType = dict() self.IdtoObjectType = dict() self.PropIdToDict = dict() self.RNEFnameToPropType = dict() from requests.auth import HTTPBasicAuth from requests import Session from zeep.cache import SqliteCache from zeep.transports import Transport session = Session() session.auth = HTTPBasicAuth(username, password) transport = Transport(cache=SqliteCache(), session=session) from zeep import Client, Settings settings = Settings(strict=False, xml_huge_tree=True) #settings = zeep.Settings(extra_http_headers={'Authorization': 'Bearer ' + token}) self.logger = configure_logging(logging.getLogger(__name__)) try: self.SOAPclient = Client(wsdl=url, transport=transport, settings=settings) self.__load_model() print('Connected to Resnet API server:\n%s as %s' % (url, username)) except Exception as error: self.logger.error( "Pathway Studio server connection failed: {error}".format( error=error)) raise ConnectionError( f"Server connection failed. Wrong or inaccessible url: {url}" ) from None
def consultar_cotizaciones_zeep(self, request, fdesde, fhasta, grupo, moneda): wsdl = "https://cotizaciones.bcu.gub.uy/wscotizaciones/servlet/awsbcucotizaciones?wsdl" settings = Settings(strict=False, xml_huge_tree=True) client2 = zeep.Client(wsdl=wsdl, settings=settings) request_zeep = { 'Entrada': { 'Moneda': { 'item': moneda }, 'FechaDesde': fdesde.isoformat(), 'FechaHasta': fhasta.isoformat(), 'Grupo': '0', } } respuesta_ws_cotiza_zeep = client2.service.Execute(**request_zeep) status_zeep = respuesta_ws_cotiza_zeep[ 'respuestastatus'] #Diccionario con 'status', 'codigoerror', 'mensaje' #Lista con Diccionarios, cada diccionario contiene: 'Fecha', 'Moneda', 'Nombre', 'CodigoISO', 'Emisor', 'TCC', 'TCV', 'ArbAct', 'FormaArbitrar' cotizaciones_zeep = respuesta_ws_cotiza_zeep['datoscotizaciones'][ 'datoscotizaciones.dato'] return { 'status_zeep': status_zeep, 'cotizaciones_zeep': cotizaciones_zeep }
def __init__(self, username, password, cucm, cucm_version): """ :param username: ris username :param password: ris password :param cucm: UCM IP address :param cucm_version: UCM version example usage: >>> from ris import RIS >>> ucm = RIS('ris_user', 'ris_pass', '192.168.200.10', '11.5') """ wsdl = 'https://' + cucm + ':8443/realtimeservice2/services/RISService70?wsdl' session = Session() session.verify = False session.auth = HTTPBasicAuth(username, password) settings = Settings(strict=False, xml_huge_tree=True) transport = Transport(session=session, timeout=10, cache=SqliteCache()) ris_client = Client(wsdl, settings=settings, transport=transport) self.wsdl = wsdl self.username = username self.password = password self.cucm = cucm self.cucm_version = cucm_version self.UUID_PATTERN = re.compile( r'^[\da-f]{8}-([\da-f]{4}-){3}[\da-f]{12}$', re.IGNORECASE) self.client = ris_client.create_service( "{http://schemas.cisco.com/ast/soap}RisBinding", f"https://{cucm}:8443/realtimeservice2/services/RISService70")
def __init__(self, username, password, cucm, cucm_version): cwd = os.path.dirname(os.path.abspath(__file__)) if os.name == "posix": wsdl = Path(f"{cwd}/schema/{cucm_version}/AXLAPI.wsdl").as_uri() else: wsdl = str( Path(f"{cwd}/schema/{cucm_version}/AXLAPI.wsdl").absolute()) session = Session() session.verify = False session.auth = HTTPBasicAuth(username, password) settings = Settings(strict=False, xml_huge_tree=True, xsd_ignore_sequence_order=True) transport = Transport(session=session, timeout=10, cache=SqliteCache()) axl_client = Client(wsdl, settings=settings, transport=transport) self.wsdl = wsdl self.username = username self.password = password self.wsdl = wsdl self.cucm = cucm self.cucm_version = cucm_version self.UUID_PATTERN = re.compile( r"^[\da-f]{8}-([\da-f]{4}-){3}[\da-f]{12}$", re.IGNORECASE) self.client = axl_client.create_service( "{http://www.cisco.com/AXLAPIService/}AXLAPIBinding", f"https://{cucm}:8443/axl/", )
def main(api_key, mastr_number, limit, step, start, filter_type, units_file): wsdl = 'https://www.marktstammdatenregister.de/MaStRAPI/wsdl/mastr.wsdl' transport = Transport(cache=SqliteCache()) settings = Settings(strict=False, xml_huge_tree=True) client = Client(wsdl=wsdl, transport=transport, settings=settings) client_bind = client.bind('Marktstammdatenregister','Anlage') writer = csv.DictWriter(units_file, field_names) writer.writeheader() total = total_filtered = 0 logging.getLogger('zeep').setLevel(logging.CRITICAL) for current_step in range(start, math.ceil(limit/step)): try: try: c = client_bind.GetListeAlleEinheiten(apiKey=api_key, marktakteurMastrNummer=mastr_number, startAb=step*current_step, limit=step) respond = serialize_object(c) except Fault as e: print('Probably reached the end, saving file: ' + e.message) break filtered = [dict(x) for x in respond['Einheiten'] if x['Einheittyp'] == filter_type] print(f'[{current_step}] Fetched {len(respond["Einheiten"])} entries out of which {len(filtered)} was used') writer.writerows(filtered) total += len(respond["Einheiten"]) total_filtered += len(filtered) except KeyboardInterrupt: print('Aborting fetching!') break print(f'Fetched in total {total} entries which {total_filtered} was used.')
def get_soap_client_number(): """Возвращает справочник контактов клиентов из SOAP-сервиса""" wsdl = auth.wsdl user = auth.user_soap password = auth.password_soap settings = Settings( strict=True # raw_response=True # ответ без обработки lxml-модулем # force_https=False # xml_huge_tree=True # ограничение глубины xml-дерева # forbid_dtd=True # forbid_entities=False # xsd_ignore_sequence_order=True ) session = Session() session.auth = HTTPBasicAuth(user, password) client = Client(wsdl=wsdl, settings=settings, transport=Transport(session=session)) request = client.service.ExecProcJSON('Service', params) result = ast.literal_eval( request) # Предобразование строки в список словарей return result
def __init__(self, ): session = Session() session.verify = False transport = Transport(session=session) settings = Settings(strict=False, xml_huge_tree=True) self.client_login = Client( 'https://tkps-http.ldz.lv/kpsws-webapp/Login?wsdl', settings=settings, transport=transport, plugins=[ KpsLoginPlugin(), ]) self.client_classifiers = Client( 'https://tkps-http.ldz.lv:443/kpsws-webapp/Classifiers?wsdl', settings=settings, transport=transport, plugins=[ KpsLoginPlugin(), ]) self.client_cnotes = Client( 'https://tkps-http.ldz.lv/kpsws-webapp/Cnotes?wsdl', settings=settings, transport=transport, plugins=[ KpsLoginPlugin(), ])
def get_n11com_client(servicecategory): soapserver = "https://api.n11.com" strictsetting = False rawresponsesetting = False wsdl = soapserver + get_n11com_servicepath(servicecategory) settings = Settings(strict=strictsetting, raw_response=rawresponsesetting) return Client(wsdl, settings=settings)
def test_wsdl_dtd_entities_rules(): wsdl_declaration = u"""<!DOCTYPE Author [ <!ENTITY writer "Donald Duck."> ]> <wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://tests.python-zeep.org/xsd-main" xmlns:mine="http://tests.python-zeep.org/xsd-secondary" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" targetNamespace="http://tests.python-zeep.org/xsd-main"> <wsdl:types> <xsd:schema targetNamespace="http://tests.python-zeep.org/xsd-main" xmlns:tns="http://tests.python-zeep.org/xsd-main"> <xsd:element name="input" type="xsd:string"/> </xsd:schema> </wsdl:types> <wsdl:message name="message-1"> <wsdl:part name="response" element="tns:input"/> </wsdl:message> <wsdl:portType name="TestPortType"> <wsdl:operation name="TestOperation1"> <wsdl:input message="message-1"/> </wsdl:operation> </wsdl:portType> </wsdl:definitions> """.strip() transport = DummyTransport() transport.bind('http://tests.python-zeep.org/schema-2.wsdl', wsdl_declaration) with pytest.raises(DTDForbidden): wsdl.Document(StringIO(wsdl_declaration), transport, settings=Settings(forbid_dtd=True)) with pytest.raises(EntitiesForbidden): wsdl.Document(StringIO(wsdl_declaration), transport) document = wsdl.Document(StringIO(wsdl_declaration), transport, settings=Settings(forbid_entities=False)) document.dump()
def soap_request(url, params: Params): headerArr = {} settings = Settings(strict=False, xml_huge_tree=True, extra_http_headers=headerArr) client = Client(url, settings=settings) requestData = params.get_request_body() return client.service.calculate(**requestData)
def GetStopDataByRoutesCSV(): starttime = time.time() settings = Settings(force_https=False, raw_response=True) client = Client('http://rtpi.dublinbus.ie/DublinBusRTPIService.asmx?WSDL', settings=settings) routeList = pandas.read_csv("/dublinbus/GetRoute.csv", header=0)["Route"].tolist() ##GetStopDataByRoutes: Each Route route = [] directionList = [] stopList = [] addressList = [] locationList = [] seqnumberList = [] seqnumberextList = [] for routeNumber in routeList: print('Retriving stop information for route: ' + routeNumber) routeStops = client.service.GetStopDataByRoute(routeNumber) dom = ET.fromstring(routeStops.content) for stopNumber in dom.findall('.//StopNumber'): route.append(routeNumber) stopList.append(stopNumber.text) for Direction in dom.findall('.//Direction'): directionList.append(Direction.text) for Address in dom.findall('.//Address'): addressList.append(Address.text) for Location in dom.findall('.//Location'): locationList.append(Location.text) for SeqNumber in dom.findall('.//SeqNumber'): seqnumberList.append(SeqNumber.text) for SeqNumberExt in dom.findall('.//SeqNumberExt'): seqnumberextList.append(SeqNumberExt.text) print('There are total number of ' + str(len(stopList)) + ' stops retrived from ' + str(len(routeList)) + ' routes') #print(route)#test #print(stopList)#test d = { 'Route': route, 'StopID': stopList, 'Direction': directionList, 'Address': addressList, 'Location': locationList, 'SeqNumber': seqnumberList, 'SeqNumberExt': seqnumberextList } df = pandas.DataFrame(data=d) df.to_csv("/dublinbus/GetStopDataByRoutes.csv", index=False, header=True) endtime = time.time() print( '-----------"GetStopDataByRoutes.csv" File saved on Desktop----------') print('----------%s seconds----------' % (endtime - starttime))
def client_soap(config_file): logger.debug('Ha entrado en la funcion client_soap()') csp_cmserver = cspconfigfile['CUCM']['server'] csp_username = cspconfigfile['CUCM']['user'] csp_password = cspconfigfile['CUCM']['pass'] csp_version = cspconfigfile['CUCM']['version'] if platform.system() == 'Windows': logger.debug('El sistema operativo es: %s' % (platform.system())) wsdl = 'file://' + os.getcwd().replace ("\\","//") + '//Schema//CUCM//' + csp_version + '//AXLAPI.wsdl' else: logger.debug('El sistema operativo es: %s' % (platform.system())) wsdl = 'file://' + os.getcwd() + '/Schema/CUCM/' + csp_version + '/AXLAPI.wsdl' csp_location = 'https://' + csp_cmserver + '/axl/' logger.debug('El valor de csp_cmserver es: %s' % (csp_cmserver)) logger.debug('El valor de csp_username es: %s' % (csp_username)) logger.debug('El valor de csp_version es: %s' % (csp_version)) logger.debug('El valor de csp_location es: %s' % (csp_location)) logger.debug('El valor de wsdl es: %s' % (wsdl)) # history shows http_headers global history history = HistoryPlugin() # The first step is to create a SOAP client session session = Session() # We avoid certificate verification by default, but you can uncomment and set # your certificate here, and comment out the False setting #session.verify = CERT session.verify = False session.auth = HTTPBasicAuth(csp_username, csp_password) transport = Transport(session=session, timeout=10, cache=SqliteCache()) # strict=False is not always necessary, but it allows zeep to parse imperfect XML settings = Settings(strict=False, xml_huge_tree=True) try: csp_soap_client = Client(wsdl, settings=settings, transport=transport, plugins=[MyLoggingPlugin(),history], ) service = csp_soap_client.create_service("{http://www.cisco.com/AXLAPIService/}AXLAPIBinding", csp_location) except: logger.error('Se ha producido un error al crear el cliente soap') logger.debug(sys.exc_info()) logger.error(sys.exc_info()[1]) sys.exit() else: logger.info('Se ha creado el cliente SOAP.') return service
def start_rating_transaction(self, wsdl_path): settings = Settings(strict=False) self.client = Client('file:///%s' % wsdl_path.lstrip('/'), plugins=[LogPlugin(self.debug_logger)], settings=settings) self.factory = self.client.type_factory('ns0') self.VersionId = self.factory.VersionId() self.VersionId.ServiceId = 'crs' self.VersionId.Major = '16' self.VersionId.Intermediate = '0' self.VersionId.Minor = '0'
def CUZKClient(wsdl): transport = Transport(cache=SqliteCache()) settings = Settings(raw_response=False, strict=False, xml_huge_tree=True) settings = Settings(strict=False, xml_huge_tree=True) relevantWsdls = prodWsdls creds = None if TRIAL: relevantWsdls = trialWsdls creds = ["WSTESTO", "WSHESLOO"] if not creds[0] and not creds[1]: print("Nastavte creds ve funkci CUZKClient") sys.exit(0) return Client( relevantWsdls[wsdl], transport=transport, wsse=UsernameToken(*creds), settings=settings, )
def soap_call(envData,service, data): settings = Settings(strict=False, xml_huge_tree=True) client = Client(envData["url"], settings=settings) with client.settings(raw_response=True): response = client.service.Add(**data) if response.status_code == 200: root = ET.fromstring(response.content) return root else: module_logger.error(f'Response Code:{response.status_code}')
def soapinfo(CUCM_URL, USERNAME, PASSWD, WSDL_URL): #Create SOAP Session session = Session() session.verify = False session.auth = HTTPBasicAuth(USERNAME, PASSWD) transport = Transport(session=session, timeout=10, cache=SqliteCache()) settings = Settings(strict=False, xml_huge_tree=True) client = Client(WSDL_URL, settings=settings, transport=transport) service = client.create_service( "{http://www.cisco.com/AXLAPIService/}AXLAPIBinding", CUCM_URL) return service
def __init__(self, start_date, project_id, dataset_id): self.semaphore = threading.Semaphore(3) self.lock = threading.Lock() self.client = bigquery.Client(project_id) self.dataset_id = dataset_id self.current_date = datetime.strptime(start_date, '%Y-%m-%d') self.current_page = 1 self.processed = 0 self.current_throttle = 0 self.url = BaseConfig.API_CEIDG_URL settings = Settings(strict=False, xml_huge_tree=True) self.soap_client = Client(self.url, settings=settings)
def __init__(self): try: session = Session() session.auth = HTTPBasicAuth(axl_client.username,axl_client.password) session.verify = False transport = Transport(session = session,timeout = 3) settings = Settings(strict = False,xml_huge_tree = True) plugin = [ MyLoggingPlugin() ] if axl_client.DEBUG else [ ] client = Client(wsdl=axl_client.WSDL_FILE,settings = settings,transport=transport, plugins=plugin) self.service = client.create_service(axl_client.axl_binding,axl_client.CallManager) except Exception as e: logger._write("axl initialize failed %s" % e, debugtype="DEBUG")
def connect(self): """ """ session = Session() settings = Settings(strict=False, xml_huge_tree=True) session.auth = HTTPBasicAuth(self.username, self.password) transport = Transport(session=session) self.client = Client(self.wsdl_url, transport=transport, settings=settings) self.service = self.client.bind('Titulus4Service', 'Titulus4') return self.client
def CustomSoapClient (self): self.Logger.debug('La direccion IP para la conexion SOAP es: %s' % (self.ipaddress)) # Comprobamos el SO sobre el que esta funcionando el servidor de Flask if platform.system() == 'Windows': self.Logger.debug('El sistema operativo es: %s' % (platform.system())) CustomWSDL = 'file://' + os.getcwd().replace ("\\","//") + '//Schema//CUCM//' + self.version + '//AXLAPI.wsdl' else: self.Logger.debug('El sistema operativo es: %s' % (platform.system())) CustomWSDL = 'file://' + os.getcwd() + '/Schema/CUCM/' + self.version + '/AXLAPI.wsdl' self.Logger.debug('El archivo WSDL es: %s' % (CustomWSDL)) # Definimos la URL de AXL self.location = 'https://' + self.ipaddress + ':' + self.port + '/axl/' # History shows http_headers global CustomHistory CustomHistory = HistoryPlugin() # The first step is to create a SOAP client session CustomSession = Session() # We avoid certificate verification by default, but you can uncomment and set # your certificate here, and comment out the False setting #session.verify = CERT CustomSession.verify = False CustomSession.auth = HTTPBasicAuth(self.username, self.password) CustomTransport = Transport(session=CustomSession, timeout=10, cache=SqliteCache()) urllib3.disable_warnings() # strict=False is not always necessary, but it allows zeep to parse imperfect XML CustomSettings = Settings(strict=False, xml_huge_tree=True) try: CustomSOAPClient = Client(CustomWSDL, settings=CustomSettings, transport=CustomTransport, plugins=[MyLoggingPlugin(),CustomHistory], ) CustomService = CustomSOAPClient.create_service("{http://www.cisco.com/AXLAPIService/}AXLAPIBinding", self.location) except: self.Logger.error('Se ha producido un error al crear el cliente SOAP') self.Logger.debug(sys.exc_info()) self.Logger.error(sys.exc_info()[1]) sys.exit() else: self.Logger.info('Se ha creado el cliente SOAP') return (CustomService)
def _login_soap(self, username=None, password=None, security_token=None, url=None, wsdl=None, metadata=False): """Login via SOAP (Simple Object Access Protocol) Args: username (str): The Salesforce user username password (str): The Salesforce user password security_token (str): The Salesforce user Security Token url (str): The Salesforce SOAP API URL used for login wsdl (str): The path to the WSDL (Web Services Description Language) file metadata (bool): Whether or not to get the metadata server URL Returns: A tuple containing the session ID and (metadata) server URL """ # Create client with setting of disable strict mode, use recovery mode setting = Settings(strict=False) client = Client(wsdl, settings=setting) try: # Attempt to make the request for the response r = client.service.login(username, password + security_token) except exceptions.Fault: # Return None for now if exception return None # Check to see if the client service succeeded if r is not None: # Get the sessionId session_id = r['sessionId'] if metadata: # Get the `metadataServerUrl` if requested metadata_server_url = r['metadataServerUrl'] # Return a tuple of the session ID and metadata server URL return (session_id, metadata_server_url) else: # Get the `serverUrl` server_url = r['serverUrl'] # Return a tuple of the session ID and server URL return (session_id, server_url) # Return None for now if error return None
def get_client(self, endpoint): if endpoint not in self.clients: wsdl = "https://{}/Panopto/PublicAPI/{}/{}.svc?singleWsdl".format( self.host, ENDPOINTS[endpoint], endpoint) transport = Transport(session=Session(), cache=SqliteCache()) settings = Settings(strict=False) self.clients[endpoint] = Client(wsdl, transport=transport, service_name=endpoint, settings=settings) return self.clients[endpoint]
def setClient(self, wsdl): """ set soap client using a wsdl URL Parameters ---------- wsdl: str provide a URL string to a fewsPi wsdl service (eg. 'http://www.oms-waddenzee.nl:8081/FewsPiService/fewspiservice?wsdl' or 'http://localhost:8101/FewsPiService?wsdl') """ settings = Settings(xml_huge_tree=True) self.client = Client(wsdl=wsdl, settings=settings)
def __init__(self, login: str, password: str): """ Инициализация API клиента сервиса отслеживания посылок. :param login: Логин от системы трекинга :param password: Пароль от системы трекинга """ self._login = login self._password = password self._client = CachingClient( 'https://tracking.russianpost.ru/rtm34?wsdl', settings=Settings(strict=False), )
class EconomicSOAPApi: wsdl = 'https://api.e-conomic.com/secure/api1/EconomicWebService.asmx?wsdl' settings = Settings() session = Session() transport = Transport(session=session) client = zeep.Client(wsdl=wsdl, settings=settings, transport=transport) def __init__(self) -> None: self.login() super().__init__() def login(self): self.client.service.ConnectWithToken(token=X_AGREEMENT_GRANT_TOKEN, appToken=X_APP_SECRET_TOKEN)
def get_client( wsdl: str = CHARITY_COMMISSION_WSDL, raw_response: bool = False, api_key_name: str = CHARITY_COMMISSION_API_KEY_NAME, api_key_value: Optional[CharityAPIKeyType] = CHARITY_COMMISSION_API_KEY, plugins: List[Plugin] = None, **kwargs, ) -> Client: """Generate a Client for querying Charities Commision API.""" settings: Settings = Settings(strict=False, xml_huge_tree=True, raw_response=raw_response) plugins = ([CharitiesAuthPlugin(api_key_name, api_key_value)] if not plugins else plugins) return Client(wsdl=wsdl, settings=settings, plugins=plugins, **kwargs)
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 GetRouteCSV(): starttime = time.time() settings = Settings(force_https=False, raw_response=True) client = Client('http://rtpi.dublinbus.ie/DublinBusRTPIService.asmx?WSDL', settings=settings) ##GetRoutes routes = client.service.GetRoutes(0) dom = ET.fromstring(routes.content) routeList = [] SeqNumberList = [] FromList = [] TowardsList = [] IsStagedList = [] IsXpressoList = [] IsNitelinkList = [] IsMinimumFareList = [] for number in dom.findall('.//{http://dublinbus.ie/}Number'): routeList.append(number.text) for SeqNumber in dom.findall('.//{http://dublinbus.ie/}SeqNumber'): SeqNumberList.append(SeqNumber.text) for From in dom.findall('.//{http://dublinbus.ie/}From'): FromList.append(From.text) for Towards in dom.findall('.//{http://dublinbus.ie/}Towards'): TowardsList.append(Towards.text) for IsStaged in dom.findall('.//{http://dublinbus.ie/}IsStaged'): IsStagedList.append(IsStaged.text) for IsXpresso in dom.findall('.//{http://dublinbus.ie/}IsXpresso'): IsXpressoList.append(IsXpresso.text) for IsNitelink in dom.findall('.//{http://dublinbus.ie/}IsNitelink'): IsNitelinkList.append(IsNitelink.text) for IsMinimumFare in dom.findall('.//{http://dublinbus.ie/}IsMinimumFare'): IsMinimumFareList.append(IsMinimumFare.text) # d = {'Route': routeList, 'SeqNumber': SeqNumberList, 'From': FromList, 'Towards': TowardsList, # 'IsStaged': IsStagedList, 'IsXpresso': IsXpressoList, 'IsNitelink': IsNitelinkList, # 'IsMinimumFare': IsMinimumFareList} # df = pandas.DataFrame(data=d) # #print(df)#test # df.to_csv("/dublinbus/GetRoute.csv", index=False, header=True) endtime = time.time() dur = endtime - starttime print('----------"GetRoute.csv" File saved on Desktop----------') print('----------%s seconds-----------' % dur)
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