def getTypesModuleName(self): '''return module name. ''' assert self.wsdl is not None, 'initialize, call fromWSDL' if self.types_module_name is not None: return self.types_module_name wsm = WriteServiceModule(self.wsdl) return wsm.getTypesModuleName()
def getClientModuleName(self): '''return module name. ''' assert self.wsdl is not None, 'initialize, call fromWSDL' if self.client_module_name is not None: return self.client_module_name wsm = WriteServiceModule(self.wsdl, do_extended=self.do_extended) return wsm.getClientModuleName()
def getMessagesModuleName(self): """return module name. """ assert self.wsdl is not None, "initialize, call fromWSDL" if self.messages_module_name is not None: return self.messages_module_name wsm = WriteServiceModule(self.wsdl, do_extended=self.do_extended) return wsm.getMessagesModuleName()
def _wsdl2py(options, wsdl): if options.twisted: from ZSI.generate.containers import ServiceHeaderContainer try: ServiceHeaderContainer.imports.remove('from ZSI import client') except ValueError: pass ServiceHeaderContainer.imports.append('from ZSI.twisted import client') if options.simple_naming: # Use a different client suffix # WriteServiceModule.client_module_suffix = "_client" # Write messages definitions to a separate file. #wsdl2pyServiceDescription.separate_messages = True # Use more simple type and element class names containers.SetTypeNameFunc(lambda n: '%s_' % (NC_to_CN(n))) containers.SetElementNameFunc(lambda n: '%s' % (NC_to_CN(n))) # Don't add "_" to the attribute name (remove when --aname works well) containers.ContainerBase.func_aname = lambda instnc, n: TextProtect( str(n)) # write out the modules with their names rather than their number. utility.namespace_name = lambda cls, ns: utility.Namespace2ModuleName( ns) files = [] append = files.append if isinstance(wsdl, XMLSchema.XMLSchema): wsm = WriteServiceModule(_XMLSchemaAdapter(wsdl.location, wsdl), addressing=options.address) else: wsm = WriteServiceModule(wsdl, addressing=options.address) client_mod = wsm.getClientModuleName() client_file = join(options.output_dir, '%s.py' % client_mod) append(client_file) fd = open(client_file, 'w+') wsm.writeClient(fd) fd.close() types_mod = wsm.getTypesModuleName() types_file = join(options.output_dir, '%s.py' % types_mod) append(types_file) fd = open(types_file, 'w+') wsm.writeTypes(fd) fd.close() return files
def _wsdl2py(options, wsdl): if options.twisted: from ZSI.generate.containers import ServiceHeaderContainer try: ServiceHeaderContainer.imports.remove('from ZSI import client') except ValueError: pass ServiceHeaderContainer.imports.append('from ZSI.twisted import client') if options.simple_naming: # Use a different client suffix # WriteServiceModule.client_module_suffix = "_client" # Write messages definitions to a separate file. #wsdl2pyServiceDescription.separate_messages = True # Use more simple type and element class names containers.SetTypeNameFunc( lambda n: '%s_' %(NC_to_CN(n)) ) containers.SetElementNameFunc( lambda n: '%s' %(NC_to_CN(n)) ) # Don't add "_" to the attribute name (remove when --aname works well) containers.ContainerBase.func_aname = lambda instnc,n: TextProtect(str(n)) # write out the modules with their names rather than their number. utility.namespace_name = lambda cls, ns: utility.Namespace2ModuleName(ns) files = [] append = files.append if isinstance(wsdl, XMLSchema.XMLSchema): wsm = WriteServiceModule(_XMLSchemaAdapter(wsdl.location, wsdl), addressing=options.address) else: wsm = WriteServiceModule(wsdl, addressing=options.address) client_mod = wsm.getClientModuleName() client_file = join(options.output_dir, '%s.py' %client_mod) append(client_file) fd = open(client_file, 'w+') # FIXME: adicionando a opcao com twisted utilizando o client que # alterei wsm.writeClient(fd, twisted=options.twisted) fd.close() types_mod = wsm.getTypesModuleName() types_file = join(options.output_dir, '%s.py' %types_mod) append(types_file) fd = open(types_file, 'w+' ) wsm.writeTypes(fd) fd.close() return files
def GetPartsSubNames(args, wsdl): do_extended = True from ZSI.generate.wsdl2python import WriteServiceModule, SchemaDescription wsm = WriteServiceModule(wsdl, do_extended=do_extended) wsm.gatherNamespaces() toReturn = [] for arg in args: argSubnames = [] for l in wsm.usedNamespaces.values(): for schema in l: sd = SchemaDescription(do_extended=do_extended) sd.fromSchema(schema) argNamespace = arg.element[0] if (sd.targetNamespace == argNamespace): for i in sd.items: # arg.name is the part name, but we want it's type argElementType = arg.element[1] if str(argElementType) == str(i.content.name): argSubnames = [] # I'm not sure when the name attribute was dropped # but at some point, or in some circumstance it's not # there, but instead a ref attribute is there which is # tuple of (namespace, name). This hack fixes things, # but I'm not sure why this happens or has happened. # IRJ - 2005-05-25 if i.content.mgContent != None: for c in i.content.mgContent: nValue = "None" if c.isWildCard(): nValue = "any" elif "name" in c.attributes: nValue = c.attributes["name"] elif "ref" in c.attributes: nValue = c.attributes["ref"][1] argSubnames.append(nValue) toReturn.append(argSubnames) return toReturn
def wsdl2py(args=None): """ A utility for automatically generating client interface code from a wsdl definition, and a set of classes representing element declarations and type definitions. This will produce two files in the current working directory named after the wsdl definition name. eg. <definition name='SampleService'> SampleService.py SampleService_types.py """ op = optparse.OptionParser(usage="usage: %prog [options]", description=wsdl2py.__doc__) # Basic options op.add_option("-f", "--file", action="store", dest="file", default=None, type="string", help="FILE to load wsdl from") op.add_option("-u", "--url", action="store", dest="url", default=None, type="string", help="URL to load wsdl from") op.add_option("-x", "--schema", action="store_true", dest="schema", default=False, help="process just the schema from an xsd file [no services]") op.add_option("-d", "--debug", action="callback", callback=SetDebugCallback, help="debug output") # WS Options op.add_option("-a", "--address", action="store_true", dest="address", default=False, help="ws-addressing support, must include WS-Addressing schema.") # pyclass Metaclass op.add_option("-b", "--complexType", action="callback", callback=SetPyclassMetaclass, callback_kwargs={'module':'ZSI.generate.pyclass', 'metaclass':'pyclass_type'}, help="add convenience functions for complexTypes, including Getters, Setters, factory methods, and properties (via metaclass). *** DONT USE WITH --simple-naming ***") # Lazy Evaluation of Typecodes (done at serialization/parsing when needed). op.add_option("-l", "--lazy", action="callback", callback=SetUpLazyEvaluation, callback_kwargs={}, help="EXPERIMENTAL: recursion error solution, lazy evalution of typecodes") # Use Twisted op.add_option("-w", "--twisted", action="callback", callback=SetUpTwistedClient, callback_kwargs={'module':'ZSI.generate.pyclass', 'metaclass':'pyclass_type'}, help="generate a twisted.web client, dependencies python>=2.4, Twisted>=2.0.0, TwistedWeb>=0.5.0") # Extended generation options op.add_option("-e", "--extended", action="store_true", dest="extended", default=False, help="Do Extended code generation.") op.add_option("-z", "--aname", action="store", dest="aname", default=None, type="string", help="pass in a function for attribute name creation") op.add_option("-t", "--types", action="store", dest="types", default=None, type="string", help="file to load types from") op.add_option("-o", "--output-dir", action="store", dest="output_dir", default=".", type="string", help="Write generated files to OUTPUT_DIR") op.add_option("-s", "--simple-naming", action="store_true", dest="simple_naming", default=False, help="Simplify generated naming.") op.add_option("-c", "--clientClassSuffix", action="store", dest="clientClassSuffix", default=None, type="string", help="Suffix to use for service client class (default \"SOAP\")") op.add_option("-m", "--pyclassMapModule", action="store", dest="pyclassMapModule", default=None, type="string", help="Python file that maps external python classes to a schema type. The classes are used as the \"pyclass\" for that type. The module should contain a dict() called mapping in the format: mapping = {schemaTypeName:(moduleName.py,className) }") if args is None: (options, args) = op.parse_args() else: (options, args) = op.parse_args(args) if not xor(options.file is None, options.url is None): print('Must specify either --file or --url option') sys.exit(os.EX_USAGE) location = options.file if options.url is not None: location = options.url if options.schema is True: reader = XMLSchema.SchemaReader(base_url=location) else: reader = WSDLTools.WSDLReader() load = reader.loadFromFile if options.url is not None: load = reader.loadFromURL wsdl = None try: wsdl = load(location) except Exception as e: print("Error loading %s: \n\t%s" % (location, e)) # exit code UNIX specific, Windows? sys.exit(os.EX_NOINPUT) if options.simple_naming: # Use a different client suffix WriteServiceModule.client_module_suffix = "_client" # Write messages definitions to a separate file. ServiceDescription.separate_messages = True # Use more simple type and element class names containers.SetTypeNameFunc( lambda n: '%s_' %(NC_to_CN(n)) ) containers.SetElementNameFunc( lambda n: '%s' %(NC_to_CN(n)) ) # Don't add "_" to the attribute name (remove when --aname works well) containers.ContainerBase.func_aname = lambda instnc,n: TextProtect(str(n)) # write out the modules with their names rather than their number. utility.namespace_name = lambda cls, ns: utility.Namespace2ModuleName(ns) if options.clientClassSuffix: from ZSI.generate.containers import ServiceContainerBase ServiceContainerBase.clientClassSuffix = options.clientClassSuffix if options.schema is True: wsdl = formatSchemaObject(location, wsdl) if options.aname is not None: args = options.aname.rsplit('.',1) assert len(args) == 2, 'expecting module.function' # The following exec causes a syntax error. #exec('from %s import %s as FUNC' %(args[0],args[1])) assert isinstance(FUNC, collections.Callable),\ '%s must be a callable method with one string parameter' %options.aname from ZSI.generate.containers import TypecodeContainerBase TypecodeContainerBase.func_aname = staticmethod(FUNC) if options.pyclassMapModule != None: mod = __import__(options.pyclassMapModule) components = options.pyclassMapModule.split('.') for comp in components[1:]: mod = getattr(mod, comp) extPyClasses = mod.mapping else: extPyClasses = None wsm = WriteServiceModule(wsdl, addressing=options.address, do_extended=options.extended, extPyClasses=extPyClasses) if options.types != None: wsm.setTypesModuleName(options.types) if options.schema is False: fd = open(os.path.join(options.output_dir, '%s.py' %wsm.getClientModuleName()), 'w+') # simple naming writes the messages to a separate file if not options.simple_naming: wsm.writeClient(fd) else: # provide a separate file to store messages to. msg_fd = open(os.path.join(options.output_dir, '%s.py' %wsm.getMessagesModuleName()), 'w+') wsm.writeClient(fd, msg_fd=msg_fd) msg_fd.close() fd.close() fd = open( os.path.join(options.output_dir, '%s.py' %wsm.getTypesModuleName()), 'w+') wsm.writeTypes(fd) fd.close()
assert callable(FUNC),\ '%s must be a callable method with one string parameter' %options.aname from ZSI.generate.containers import TypecodeContainerBase TypecodeContainerBase.func_aname = staticmethod(FUNC) if options.pyclassMapModule != None: mod = __import__(options.pyclassMapModule) components = options.pyclassMapModule.split('.') for comp in components[1:]: mod = getattr(mod, comp) extPyClasses = mod.mapping else: extPyClasses = None wsm = WriteServiceModule(wsdl, addressing=options.address, do_extended=options.extended, extPyClasses=extPyClasses) if options.types != None: wsm.setTypesModuleName(options.types) if options.schema is False: fd = open( os.path.join(options.output_dir, '%s.py' % wsm.getClientModuleName()), 'w+') # simple naming writes the messages to a separate file if not options.simple_naming: wsm.writeClient(fd) else: # provide a separate file to store messages to. msg_fd = open( os.path.join(options.output_dir, '%s.py' % wsm.getMessagesModuleName()), 'w+') wsm.writeClient(fd, msg_fd=msg_fd)
#exec('from %s import %s as FUNC' %(args[0],args[1])) assert callable(FUNC),\ '%s must be a callable method with one string parameter' %options.aname from ZSI.generate.containers import TypecodeContainerBase TypecodeContainerBase.func_aname = staticmethod(FUNC) if options.pyclassMapModule != None: mod = __import__(options.pyclassMapModule) components = options.pyclassMapModule.split('.') for comp in components[1:]: mod = getattr(mod, comp) extPyClasses = mod.mapping else: extPyClasses = None wsm = WriteServiceModule(wsdl, addressing=options.address, do_extended=options.extended, extPyClasses=extPyClasses) if options.types != None: wsm.setTypesModuleName(options.types) if options.schema is False: fd = open(os.path.join(options.output_dir, '%s.py' %wsm.getClientModuleName()), 'w+') # simple naming writes the messages to a separate file if not options.simple_naming: wsm.writeClient(fd) else: # provide a separate file to store messages to. msg_fd = open(os.path.join(options.output_dir, '%s.py' %wsm.getMessagesModuleName()), 'w+') wsm.writeClient(fd, msg_fd=msg_fd) msg_fd.close() fd.close() fd = open( os.path.join(options.output_dir, '%s.py' %wsm.getTypesModuleName()), 'w+') wsm.writeTypes(fd)
def wsdl2py(args=None): """ A utility for automatically generating client interface code from a wsdl definition, and a set of classes representing element declarations and type definitions. This will produce two files in the current working directory named after the wsdl definition name. eg. <definition name='SampleService'> SampleService.py SampleService_types.py """ op = optparse.OptionParser(usage="usage: %prog [options]", description=wsdl2py.__doc__) # Basic options op.add_option( "-f", "--file", action="store", dest="file", default=None, type="string", help="FILE to load wsdl from" ) op.add_option("-u", "--url", action="store", dest="url", default=None, type="string", help="URL to load wsdl from") op.add_option( "-x", "--schema", action="store_true", dest="schema", default=False, help="process just the schema from an xsd file [no services]", ) op.add_option("-d", "--debug", action="callback", callback=SetDebugCallback, help="debug output") # WS Options op.add_option( "-a", "--address", action="store_true", dest="address", default=False, help="ws-addressing support, must include WS-Addressing schema.", ) # pyclass Metaclass op.add_option( "-b", "--complexType", action="callback", callback=SetPyclassMetaclass, callback_kwargs={"module": "ZSI.generate.pyclass", "metaclass": "pyclass_type"}, help="add convenience functions for complexTypes, including Getters, Setters, factory methods, and properties (via metaclass). *** DONT USE WITH --simple-naming ***", ) # Lazy Evaluation of Typecodes (done at serialization/parsing when needed). op.add_option( "-l", "--lazy", action="callback", callback=SetUpLazyEvaluation, callback_kwargs={}, help="EXPERIMENTAL: recursion error solution, lazy evalution of typecodes", ) # Use Twisted op.add_option( "-w", "--twisted", action="callback", callback=SetUpTwistedClient, callback_kwargs={"module": "ZSI.generate.pyclass", "metaclass": "pyclass_type"}, help="generate a twisted.web client, dependencies python>=2.4, Twisted>=2.0.0, TwistedWeb>=0.5.0", ) # Extended generation options op.add_option( "-e", "--extended", action="store_true", dest="extended", default=False, help="Do Extended code generation." ) op.add_option( "-z", "--aname", action="store", dest="aname", default=None, type="string", help="pass in a function for attribute name creation", ) op.add_option( "-t", "--types", action="store", dest="types", default=None, type="string", help="file to load types from" ) op.add_option( "-o", "--output-dir", action="store", dest="output_dir", default=".", type="string", help="Write generated files to OUTPUT_DIR", ) op.add_option( "-s", "--simple-naming", action="store_true", dest="simple_naming", default=False, help="Simplify generated naming.", ) op.add_option( "-c", "--clientClassSuffix", action="store", dest="clientClassSuffix", default=None, type="string", help='Suffix to use for service client class (default "SOAP")', ) op.add_option( "-m", "--pyclassMapModule", action="store", dest="pyclassMapModule", default=None, type="string", help='Python file that maps external python classes to a schema type. The classes are used as the "pyclass" for that type. The module should contain a dict() called mapping in the format: mapping = {schemaTypeName:(moduleName.py,className) }', ) if args is None: (options, args) = op.parse_args() else: (options, args) = op.parse_args(args) if not xor(options.file is None, options.url is None): print("Must specify either --file or --url option") sys.exit(os.EX_USAGE) location = options.file if options.url is not None: location = options.url if options.schema is True: reader = XMLSchema.SchemaReader(base_url=location) else: reader = WSDLTools.WSDLReader() load = reader.loadFromFile if options.url is not None: load = reader.loadFromURL wsdl = None try: wsdl = load(location) except Exception as e: print("Error loading %s: \n\t%s" % (location, e)) # exit code UNIX specific, Windows? sys.exit(os.EX_NOINPUT) if options.simple_naming: # Use a different client suffix WriteServiceModule.client_module_suffix = "_client" # Write messages definitions to a separate file. ServiceDescription.separate_messages = True # Use more simple type and element class names containers.SetTypeNameFunc(lambda n: "%s_" % (NC_to_CN(n))) containers.SetElementNameFunc(lambda n: "%s" % (NC_to_CN(n))) # Don't add "_" to the attribute name (remove when --aname works well) containers.ContainerBase.func_aname = lambda instnc, n: TextProtect(str(n)) # write out the modules with their names rather than their number. utility.namespace_name = lambda cls, ns: utility.Namespace2ModuleName(ns) if options.clientClassSuffix: from ZSI.generate.containers import ServiceContainerBase ServiceContainerBase.clientClassSuffix = options.clientClassSuffix if options.schema is True: wsdl = formatSchemaObject(location, wsdl) if options.aname is not None: args = options.aname.rsplit(".", 1) assert len(args) == 2, "expecting module.function" # The following exec causes a syntax error. # exec('from %s import %s as FUNC' %(args[0],args[1])) assert isinstance(FUNC, collections.Callable), ( "%s must be a callable method with one string parameter" % options.aname ) from ZSI.generate.containers import TypecodeContainerBase TypecodeContainerBase.func_aname = staticmethod(FUNC) if options.pyclassMapModule != None: mod = __import__(options.pyclassMapModule) components = options.pyclassMapModule.split(".") for comp in components[1:]: mod = getattr(mod, comp) extPyClasses = mod.mapping else: extPyClasses = None wsm = WriteServiceModule(wsdl, addressing=options.address, do_extended=options.extended, extPyClasses=extPyClasses) if options.types != None: wsm.setTypesModuleName(options.types) if options.schema is False: fd = open(os.path.join(options.output_dir, "%s.py" % wsm.getClientModuleName()), "w+") # simple naming writes the messages to a separate file if not options.simple_naming: wsm.writeClient(fd) else: # provide a separate file to store messages to. msg_fd = open(os.path.join(options.output_dir, "%s.py" % wsm.getMessagesModuleName()), "w+") wsm.writeClient(fd, msg_fd=msg_fd) msg_fd.close() fd.close() fd = open(os.path.join(options.output_dir, "%s.py" % wsm.getTypesModuleName()), "w+") wsm.writeTypes(fd) fd.close()
def main(**kw): """ From a wsdl definition create a wsdl object and run the wsdl2python generator. """ options, args = doCommandLine(**kw) location = options.file or options.url if options.schema is True: reader = XMLSchema.SchemaReader(base_url=location) else: reader = WSDLTools.WSDLReader() wsdl = None if options.file is not None: wsdl = reader.loadFromFile(location) elif options.url is not None: wsdl = reader.loadFromURL(location) if options.simple_naming: # Use a different client suffix WriteServiceModule.client_module_suffix = "_client" # Write messages definitions to a separate file. ServiceDescription.separate_messages = True # Use more simple type and element class names containers.SetTypeNameFunc( lambda n: '%s_' %(NC_to_CN(n)) ) containers.SetElementNameFunc( lambda n: '%s' %(NC_to_CN(n)) ) # Don't add "_" to the attribute name (remove when --aname works well) containers.ContainerBase.func_aname = lambda instnc,n: TextProtect(str(n)) # write out the modules with their names rather than their number. utility.namespace_name = lambda cls, ns: utility.Namespace2ModuleName(ns) if options.clientClassSuffix: from ZSI.generate.containers import ServiceContainerBase ServiceContainerBase.clientClassSuffix = options.clientClassSuffix assert wsdl is not None, 'Must specify WSDL either with --file or --url' if options.schema is True: wsdl = formatSchemaObject(location, wsdl) if options.aname is not None: args = options.aname.rsplit('.',1) assert len(args) == 2, 'expecting module.function' # The following exec causes a syntax error. #exec('from %s import %s as FUNC' %(args[0],args[1])) assert callable(FUNC),\ '%s must be a callable method with one string parameter' %options.aname from ZSI.generate.containers import TypecodeContainerBase TypecodeContainerBase.func_aname = staticmethod(FUNC) if options.pyclassMapModule != None: mod = __import__(options.pyclassMapModule) components = options.pyclassMapModule.split('.') for comp in components[1:]: mod = getattr(mod, comp) extPyClasses = mod.mapping else: extPyClasses = None wsm = WriteServiceModule(wsdl, addressing=options.address, do_extended=options.extended, extPyClasses=extPyClasses) if options.types != None: wsm.setTypesModuleName(options.types) if options.schema is False: fd = open(os.path.join(options.output_directory, '%s.py' %wsm.getClientModuleName()), 'w+') # simple naming writes the messages to a separate file if not options.simple_naming: wsm.writeClient(fd) else: # provide a separate file to store messages to. msg_fd = open(os.path.join(options.output_directory, '%s.py' %wsm.getMessagesModuleName()), 'w+') wsm.writeClient(fd, msg_fd=msg_fd) msg_fd.close() fd.close() fd = open( os.path.join(options.output_directory, '%s.py' %wsm.getTypesModuleName()), 'w+') wsm.writeTypes(fd) fd.close()