def initialize(): def parse_error_if_not_equal(s, expected): if s != expected: err = "Parse error on version line. Was expecting '%s', got '%s'" raise RuntimeError(err % (s, expected)) reg = vistrails.core.modules.module_registry.get_module_registry() reg.add_module(ImageMagick, abstract=True) reg.add_module(Convert) reg.add_input_port(Convert, "input", (basic.File, 'the input file')) reg.add_input_port( Convert, "inputFormat", (basic.String, 'coerce interpretation of file to this format')) reg.add_output_port(Convert, "output", (basic.File, 'the output file')) reg.add_input_port(Convert, "outputFormat", (basic.String, 'Force output to be of this format')) for (name, opt, doc_string) in no_param_options: m = new_module(Convert, name, no_param_options_method_dict(opt), docstring=doc_string) reg.add_module(m) for (name, opt, paramName, paramComment) in float_param_options: m = new_module(Convert, name, float_param_options_method_dict(opt, paramName)) reg.add_module(m) reg.add_input_port(m, paramName, (basic.Float, paramComment)) reg.add_module(GaussianBlur) reg.add_input_port(GaussianBlur, "radiusSigma", [(basic.Float, 'radius'), (basic.Float, 'sigma')]) reg.add_module(Scale) reg.add_input_port(Scale, "geometry", (basic.String, 'ImageMagick geometry')) reg.add_input_port(Scale, "width", (basic.String, 'width of the geometry for operation')) reg.add_input_port(Scale, "height", (basic.String, 'height of the geometry for operation')) reg.add_module(CombineRGBA) reg.add_input_port(CombineRGBA, "r", basic.File) reg.add_input_port(CombineRGBA, "g", basic.File) reg.add_input_port(CombineRGBA, "b", basic.File) reg.add_input_port(CombineRGBA, "a", basic.File, optional=True) reg.add_input_port(CombineRGBA, "outputFormat", basic.String) reg.add_output_port(CombineRGBA, "output", basic.File)
def new_constant(name, namespace, identifier, version, widget_type=StandardConstantWidget): """new_constant(name: str, namespace: str,widget_type: QWidget type) -> Module new_constant dynamically creates a new Module derived from Constant with a widget type.""" reg = vistrails.core.modules.module_registry.get_module_registry() def __init__(self): Constant.__init__(self) @staticmethod def get_widget_class(): return widget_type @staticmethod def conversion(self): return self m = new_module(Constant, name, {'__init__': __init__, 'get_widget_class': get_widget_class, 'translate_to_python': conversion}) m.name = name m.isEnumeration = True reg.add_module(m,namespace=namespace,package=identifier, package_version=version) return m
def createPackage(self): reg = vistrails.core.modules.module_registry.get_module_registry() if self.signature in reg.packages: reg.remove_package(reg.packages[self.signature]) # create a document hash integer from the cached sax tree # "name" is what suds use as the cache key name = '%s-%s' % (abs(hash(self.address)), "wsdl") wsdl = package_cache.get(name) if not wsdl: debug.critical("File not found in SUDS cache: '%s'" % name) self.wsdlHash = '0' return self.wsdlHash = str(int(hashlib.md5(str(wsdl.root)).hexdigest(), 16)) package_id = reg.idScope.getNewId(Package.vtType) package = Package(id=package_id, load_configuration=False, name="SUDS#" + self.address, identifier=self.signature, version=self.wsdlHash, ) suds_package = reg.get_package_by_name(identifier) package._module = suds_package.module package._init_module = suds_package.init_module self.package = package reg.add_package(package) reg.signals.emit_new_package(self.signature) self.module = new_module(Module, str(self.signature)) reg.add_module(self.module, **{'package':self.signature, 'package_version':self.wsdlHash, 'abstract':True})
def createFailedPackage(self): """ Failed package is created so that the user can remove it manually using package submenu """ pm = get_package_manager() if pm.has_package(self.signature): # do nothing return reg = vistrails.core.modules.module_registry.get_module_registry() # create a document hash integer from the cached sax tree # "name" is what suds use as the cache key name = '%s-%s' % (abs(hash(self.address)), "wsdl") self.wsdlHash = '0' package_id = reg.idScope.getNewId(Package.vtType) package = Package(id=package_id, load_configuration=False, name="SUDS#" + self.address, identifier=self.signature, version=self.wsdlHash, ) suds_package = reg.get_package_by_name(identifier) package._module = suds_package.module package._init_module = suds_package.init_module self.package = package reg.add_package(package) reg.signals.emit_new_package(self.signature) self.module = new_module(Module, str(self.signature)) reg.add_module(self.module, **{'package':self.signature, 'package_version':self.wsdlHash, 'abstract':True}) self.service = -1
def initialize(namemodule,namespace,identifier, version): reg = get_module_registry() enumerationConstant = new_module(Constant, namemodule, {}) enumerationConstant.name = namemodule enumerationConstant.isEnumeration = True reg.add_module(enumerationConstant, namespace=namespace, package=identifier, package_version=version) return enumerationConstant
def initialize(): def parse_error_if_not_equal(s, expected): if s != expected: err = "Parse error on version line. Was expecting '%s', got '%s'" raise RuntimeError(err % (s, expected)) reg = vistrails.core.modules.module_registry.get_module_registry() reg.add_module(ImageMagick, abstract=True) reg.add_module(Convert) reg.add_input_port(Convert, "input", (basic.File, 'the input file')) reg.add_input_port(Convert, "inputFormat", (basic.String, 'coerce interpretation of file to this format')) reg.add_output_port(Convert, "output", (basic.File, 'the output file')) reg.add_input_port(Convert, "outputFormat", (basic.String, 'Force output to be of this format')) for (name, opt, doc_string) in no_param_options: m = new_module(Convert, name, no_param_options_method_dict(opt), docstring=doc_string) reg.add_module(m) for (name, opt, paramName, paramComment) in float_param_options: m = new_module(Convert, name, float_param_options_method_dict(opt, paramName)) reg.add_module(m) reg.add_input_port(m, paramName, (basic.Float, paramComment)) reg.add_module(GaussianBlur) reg.add_input_port(GaussianBlur, "radiusSigma", [(basic.Float, 'radius'), (basic.Float, 'sigma')]) reg.add_module(Scale) reg.add_input_port(Scale, "geometry", (basic.String, 'ImageMagick geometry')) reg.add_input_port(Scale, "width", (basic.String, 'width of the geometry for operation')) reg.add_input_port(Scale, "height", (basic.String, 'height of the geometry for operation')) reg.add_module(CombineRGBA) reg.add_input_port(CombineRGBA, "r", basic.File) reg.add_input_port(CombineRGBA, "g", basic.File) reg.add_input_port(CombineRGBA, "b", basic.File) reg.add_input_port(CombineRGBA, "a", basic.File, optional=True) reg.add_input_port(CombineRGBA, "outputFormat", basic.String) reg.add_output_port(CombineRGBA, "output", basic.File)
def initialize(namemodule, namespace, identifier, version): reg = get_module_registry() enumerationConstant = new_module(Constant, namemodule, {}) enumerationConstant.name = namemodule enumerationConstant.isEnumeration = True reg.add_module(enumerationConstant, namespace=namespace, package=identifier, package_version=version) return enumerationConstant
def createPackage(self): reg = vistrails.core.modules.module_registry.get_module_registry() if self.signature in reg.packages: reg.remove_package(reg.packages[self.signature]) # create a document hash integer from the cached sax tree # "name" is what suds use as the cache key name = '%s-%s' % (abs(hash(self.address)), "wsdl") wsdl = package_cache.get(name) if not wsdl: debug.critical("File not found in SUDS cache: '%s'" % name) self.wsdlHash = '0' return self.wsdlHash = str(int(hashlib.md5(str(wsdl.root)).hexdigest(), 16)) package_id = reg.idScope.getNewId(Package.vtType) package = Package( id=package_id, load_configuration=False, name="SUDS#" + self.address, identifier=self.signature, version=self.wsdlHash, ) suds_package = reg.get_package_by_name(identifier) package._module = suds_package.module package._init_module = suds_package.init_module self.package = package reg.add_package(package) reg.signals.emit_new_package(self.signature) self.module = new_module(Module, str(self.signature)) reg.add_module( self.module, **{ 'package': self.signature, 'package_version': self.wsdlHash, 'abstract': True })
def createFailedPackage(self): """ Failed package is created so that the user can remove it manually using package submenu """ pm = get_package_manager() if pm.has_package(self.signature): # do nothing return reg = vistrails.core.modules.module_registry.get_module_registry() # create a document hash integer from the cached sax tree # "name" is what suds use as the cache key name = '%s-%s' % (abs(hash(self.address)), "wsdl") self.wsdlHash = '0' package_id = reg.idScope.getNewId(Package.vtType) package = Package( id=package_id, load_configuration=False, name="SUDS#" + self.address, identifier=self.signature, version=self.wsdlHash, ) suds_package = reg.get_package_by_name(identifier) package._module = suds_package.module package._init_module = suds_package.init_module self.package = package reg.add_package(package) reg.signals.emit_new_package(self.signature) self.module = new_module(Module, str(self.signature)) reg.add_module( self.module, **{ 'package': self.signature, 'package_version': self.wsdlHash, 'abstract': True }) self.service = -1
def createMethodClasses(self): # register modules reg = vistrails.core.modules.module_registry.get_module_registry() self.methodClasses = {} for m in self.wsmethods.itervalues(): def compute(self): # create dict of inputs cacheable = False if self.hasInputFromPort('cacheable'): cacheable = self.getInputFromPort('cacheable') self.is_cacheable = lambda *args, **kwargs: cacheable params = {} mname = self.wsmethod.qname[0] for name in self.wsmethod.inputs: name = str(name) if self.hasInputFromPort(name): params[name] = self.getInputFromPort(name) if params[name].__class__.__name__ == 'UberClass': params[name] = params[name].value params[name] = self.service.makeDictType(params[name]) try: #import logging #logging.basicConfig(level=logging.INFO) #logging.getLogger('suds.client').setLevel(logging.DEBUG) #print "params:", str(params)[:400] #self.service.service.set_options(retxml = True) #result = getattr(self.service.service.service, mname)(**params) #print "result:", str(result)[:400] #self.service.service.set_options(retxml = False) result = getattr(self.service.service.service, mname)(**params) except Exception, e: raise ModuleError(self, "Error invoking method %s: %s"%(name, str(e))) for name, qtype in self.wsmethod.outputs.iteritems(): if isinstance(result, list): # if result is a list just set the output self.setResult(name, result) elif qtype[0] == 'Array': # if result is a type but type is a list try to extract the correct element if len(result.__keylist__): self.setResult(name, getattr(result, result.__keylist__[0])) else: self.setResult(name, result) elif result.__class__.__name__ == 'Text': # only text returned so we assume each output wants all of it self.setResult(name, str(result.trim())) elif result.__class__.__name__ == qtype[0]: # the return value is this type self.setResult(name, result) elif hasattr(result, name): self.setResult(name, getattr(result, name)) else: # nothing matches - assume it is an attribute of the correct class class UberClass: def __init__(self, value): self.value = value self.setResult(name, UberClass(result)) # create docstring inputs = ", ".join([t[0]+' '+i for i,t in m.inputs.iteritems()]) outputs = ", ".join([t[0]+' '+o for o,t in m.outputs.iteritems()]) d = """This module was created using a wrapper for SUDS (fedorahosted.org/suds/) from the WSDL spec at: %s It is a WSDL method with signature: %s(%s) Outputs: (%s) """%(self.address, m.qname[0], inputs, outputs) M = new_module(self.module, str(m.qname[0]), {"compute":compute, "wsmethod":m, "service":self, "__doc__":d}) self.methodClasses[m.qname] = M reg.add_module(M, **{'namespace':'Methods', 'package':self.signature, 'package_version':self.wsdlHash}) reg.add_input_port(self.methodClasses[m.qname], 'cacheable', wsdlTypesDict['boolean'], optional=True) # add ports for p, ptype in m.inputs.iteritems(): if ptype[1] in wsdlSchemas: c = wsdlTypesDict[ptype[0]] elif ptype in self.typeClasses: c = self.typeClasses[ptype] else: # use string as default c = wsdlTypesDict['string'] reg.add_input_port(M, p, c) for p, ptype in m.outputs.iteritems(): if ptype[1] in wsdlSchemas: c = wsdlTypesDict[ptype[0]] elif ptype in self.typeClasses: c = self.typeClasses[ptype] else: # use string as default c = wsdlTypesDict['string'] reg.add_output_port(M, p, c)
def createTypeClasses(self): # first create classes reg = vistrails.core.modules.module_registry.get_module_registry() self.typeClasses = {} for t in self.wstypes.itervalues(): def compute(self): """ 1. use type input as object or create new 2. add other inputs to obj 3. set obj and parts as outputs """ if self.wstype.enum: # only makes sure the enum is one of the valid values p = self.wstype.parts['value'] if self.hasInputFromPort(p.name): obj = self.getInputFromPort(p.name) else: obj = p.enum[0] if len(p.enum) else '' if self.hasInputFromPort('value'): obj = self.getInputFromPort('value') if obj not in p.enum: raise ModuleError(self, "'%s' is not one of the valid enums: %s" % (obj, str(p.enum)) ) self.setResult(self.wstype.qname[0], obj) self.setResult('value', obj) return if self.hasInputFromPort(self.wstype.qname[0]): obj = self.getInputFromPort(self.wstype.qname[0]) else: obj = {} s = "{%s}%s"%(self.wstype.qname[1],self.wstype.qname[0]) try: obj = self.service.service.factory.create(s) except (suds.TypeNotFound, suds.BuildError): raise ModuleError("Type not found: %s" % s) for part in self.wstype.parts.itervalues(): # if obj.__class__.__name__ == 'UberClass': # UberClass is a placeholder and its value is assumed # to be the correct attribute value if len(self.wstype.parts) == 1: setattr(obj, part.name, obj.value) else: # update each attribute if hasattr(obj.value, part.name): setattr(obj, part.name, getattr(obj.value, part.name)) if self.hasInputFromPort(part.name): p = self.getInputFromPort(part.name) if hasattr(obj, part.name): setattr(obj, part.name, p) else: # do it anyway - assume attribute missing in template setattr(obj, part.name, p) if hasattr(obj, part.name): # res = getattr(obj, part.name) self.setResult(part.name, res) self.setResult(self.wstype.qname[0], obj) # create docstring parts = ", ".join([i.type[0]+' '+i.name for i in t.parts.itervalues()]) d = """This module was created using a wrapper for SUDS (fedorahosted.org/suds/) from the WSDL spec at: %s It is a WSDL type with signature: %s(%s)"""%(self.address, t.qname[0], parts) M = new_module(self.module, str(t.qname[0]),{"compute":compute, "wstype":t, "service":self, "__doc__":d}) self.typeClasses[t.qname] = M reg.add_module(M, **{'namespace':'Types', 'package':self.signature, 'package_version':self.wsdlHash}) # then add ports for t in self.wstypes: wstype = self.wstypes[t] # get type module if t[1] in wsdlSchemas: c = wsdlTypesDict[t[0]] elif t in self.typeClasses: c = self.typeClasses[t] else: debug.critical("Cannot find module for type: " + str(t)) continue # add self ports reg.add_input_port(self.typeClasses[t], t[0], c) reg.add_output_port(self.typeClasses[t], t[0], c) for p in wstype.parts: part = wstype.parts[p] # get type module ptype = part.type if part.max is not None and (part.max == 'unbounded' or int(part.max)>1): # it can be multiple objects which means we need to make it a list c = vistrails.core.modules.basic_modules.List elif ptype[1] in wsdlSchemas: c = wsdlTypesDict[ptype[0]] elif ptype in self.typeClasses: c = self.typeClasses[ptype] else: debug.critical("Cannot find module for type: " + str(ptype)) continue # add as both input and output port reg.add_input_port(self.typeClasses[t], p, c, optional=part.optional) reg.add_output_port(self.typeClasses[t], p, c, optional=part.optional)
def createTypeClasses(self): # first create classes reg = vistrails.core.modules.module_registry.get_module_registry() self.typeClasses = {} for t in self.wstypes.itervalues(): def compute(self): """ 1. use type input as object or create new 2. add other inputs to obj 3. set obj and parts as outputs """ if self.wstype.enum: # only makes sure the enum is one of the valid values p = self.wstype.parts['value'] if self.has_input(p.name): obj = self.get_input(p.name) else: obj = p.enum[0] if len(p.enum) else '' if self.has_input('value'): obj = self.get_input('value') if obj not in p.enum: raise ModuleError( self, "'%s' is not one of the valid enums: %s" % (obj, str(p.enum))) self.set_output(self.wstype.qname[0], obj) self.set_output('value', obj) return if self.has_input(self.wstype.qname[0]): obj = self.get_input(self.wstype.qname[0]) else: obj = {} s = "{%s}%s" % (self.wstype.qname[1], self.wstype.qname[0]) try: obj = self.service.service.factory.create(s) except (suds.TypeNotFound, suds.BuildError): raise ModuleError("Type not found: %s" % s) for part in self.wstype.parts.itervalues(): # if obj.__class__.__name__ == 'UberClass': # UberClass is a placeholder and its value is assumed # to be the correct attribute value if len(self.wstype.parts) == 1: setattr(obj, part.name, obj.value) else: # update each attribute if hasattr(obj.value, part.name): setattr(obj, part.name, getattr(obj.value, part.name)) if self.has_input(part.name): p = self.get_input(part.name) if hasattr(obj, part.name): setattr(obj, part.name, p) else: # do it anyway - assume attribute missing in template setattr(obj, part.name, p) if hasattr(obj, part.name): # res = getattr(obj, part.name) self.set_output(part.name, res) self.set_output(self.wstype.qname[0], obj) # create docstring parts = ", ".join( [i.type[0] + ' ' + i.name for i in t.parts.itervalues()]) d = """This module was created using a wrapper for SUDS (fedorahosted.org/suds/) from the WSDL spec at: %s It is a WSDL type with signature: %s(%s)""" % (self.address, t.qname[0], parts) M = new_module(self.module, str(t.qname[0]), { "compute": compute, "wstype": t, "service": self, "__doc__": d }) self.typeClasses[t.qname] = M reg.add_module( M, **{ 'namespace': 'Types', 'package': self.signature, 'package_version': self.wsdlHash }) # then add ports for t in self.wstypes: wstype = self.wstypes[t] # get type module if t[1] in wsdlSchemas: c = wsdlTypesDict[t[0]] elif t in self.typeClasses: c = self.typeClasses[t] else: debug.critical("Cannot find module for type: " + str(t)) continue # add self ports reg.add_input_port(self.typeClasses[t], t[0], c) reg.add_output_port(self.typeClasses[t], t[0], c) for p in wstype.parts: part = wstype.parts[p] # get type module ptype = part.type if part.max is not None and (part.max == 'unbounded' or int(part.max) > 1): # it can be multiple objects which means we need to make it a list c = vistrails.core.modules.basic_modules.List elif ptype[1] in wsdlSchemas: c = wsdlTypesDict[ptype[0]] elif ptype in self.typeClasses: c = self.typeClasses[ptype] else: debug.critical("Cannot find module for type: " + str(ptype)) continue # add as both input and output port reg.add_input_port(self.typeClasses[t], p, c, optional=part.optional) reg.add_output_port(self.typeClasses[t], p, c, optional=part.optional)
def createMethodClasses(self): # register modules reg = vistrails.core.modules.module_registry.get_module_registry() self.methodClasses = {} for m in self.wsmethods.itervalues(): def compute(self): # create dict of inputs cacheable = False if self.has_input('cacheable'): cacheable = self.get_input('cacheable') self.is_cacheable = lambda *args, **kwargs: cacheable params = {} mname = self.wsmethod.qname[0] for name in self.wsmethod.inputs: name = str(name) if self.has_input(name): params[name] = self.get_input(name) if params[name].__class__.__name__ == 'UberClass': params[name] = params[name].value params[name] = self.service.makeDictType(params[name]) try: #import logging #logging.basicConfig(level=logging.INFO) #logging.getLogger('suds.client').setLevel(logging.DEBUG) #print "params:", str(params)[:400] #self.service.service.set_options(retxml = True) #result = getattr(self.service.service.service, mname)(**params) #print "result:", str(result)[:400] #self.service.service.set_options(retxml = False) result = getattr(self.service.service.service, mname)(**params) except Exception, e: debug.unexpected_exception(e) raise ModuleError( self, "Error invoking method %s: %s" % (mname, debug.format_exception(e))) for name, qtype in self.wsmethod.outputs.iteritems(): if isinstance(result, list): # if result is a list just set the output self.set_output(name, result) elif qtype[0] == 'Array': # if result is a type but type is a list try to extract the correct element if len(result.__keylist__): self.set_output( name, getattr(result, result.__keylist__[0])) else: self.set_output(name, result) elif result.__class__.__name__ == 'Text': # only text returned so we assume each output wants all of it self.set_output(name, str(result.trim())) elif result.__class__.__name__ == qtype[0]: # the return value is this type self.set_output(name, result) elif hasattr(result, name): self.set_output(name, getattr(result, name)) else: # nothing matches - assume it is an attribute of the correct class class UberClass(object): def __init__(self, value): self.value = value self.set_output(name, UberClass(result)) # create docstring inputs = ", ".join( [t[0] + ' ' + i for i, t in m.inputs.iteritems()]) outputs = ", ".join( [t[0] + ' ' + o for o, t in m.outputs.iteritems()]) d = """This module was created using a wrapper for SUDS (fedorahosted.org/suds/) from the WSDL spec at: %s It is a WSDL method with signature: %s(%s) Outputs: (%s) """ % (self.address, m.qname[0], inputs, outputs) M = new_module(self.module, str(m.qname[0]), { "compute": compute, "wsmethod": m, "service": self, "__doc__": d }) self.methodClasses[m.qname] = M reg.add_module( M, **{ 'namespace': 'Methods', 'package': self.signature, 'package_version': self.wsdlHash }) reg.add_input_port(self.methodClasses[m.qname], 'cacheable', wsdlTypesDict['boolean'], optional=True) # add ports for p, ptype in m.inputs.iteritems(): if ptype[1] in wsdlSchemas: c = wsdlTypesDict[ptype[0]] elif ptype in self.typeClasses: c = self.typeClasses[ptype] else: # use string as default c = wsdlTypesDict['string'] reg.add_input_port(M, p, c) for p, ptype in m.outputs.iteritems(): if ptype[1] in wsdlSchemas: c = wsdlTypesDict[ptype[0]] elif ptype in self.typeClasses: c = self.typeClasses[ptype] else: # use string as default c = wsdlTypesDict['string'] reg.add_output_port(M, p, c)
# necessary for group d['_input_ports'] = [IPort(*p[:3], depth=p[3]) for p in input_ports] d['_output_ports'] = [OPort(*p[:3], depth=p[3]) for p in output_ports] d['input_remap'] = input_remap d['output_remap'] = output_remap d['pipeline'] = pipeline # abstraction specific d['vt_fname'] = vt_fname d['vistrail'] = vistrail d['internal_version'] = internal_version d['uuid'] = uuid # print "input_ports", d['_input_ports'] # print "output_ports", d['_output_ports'] return new_module(Abstraction, name, d, docstring) def get_abstraction_dependencies(vistrail, internal_version=-1L): if isinstance(vistrail, basestring): vistrail = read_vistrail(vistrail) if internal_version == -1L: internal_version = vistrail.get_latest_version() pipeline = vistrail.getPipeline(internal_version) packages = {} def pipeline_deps(pipeline): for module in pipeline.module_list: if module.is_group(): pipeline_deps(module.pipeline) continue if module.package not in packages:
# necessary for group d['_input_ports'] = [IPort(*p[:3], depth=p[3]) for p in input_ports] d['_output_ports'] = [OPort(*p[:3], depth=p[3]) for p in output_ports] d['input_remap'] = input_remap d['output_remap'] = output_remap d['pipeline'] = pipeline # abstraction specific d['vt_fname'] = vt_fname d['vistrail'] = vistrail d['internal_version'] = internal_version d['uuid'] = uuid # print "input_ports", d['_input_ports'] # print "output_ports", d['_output_ports'] return new_module(Abstraction, name, d, docstring) def get_abstraction_dependencies(vistrail, internal_version=-1L): if isinstance(vistrail, basestring): vistrail = read_vistrail(vistrail) if internal_version == -1L: internal_version = vistrail.get_latest_version() # action = vistrail.actionMap[internal_version] pipeline = vistrail.getPipeline(internal_version) packages = {} for module in pipeline.module_list: if module.package not in packages: packages[module.package] = set() packages[module.package].add(module.descriptor_info) return packages
f = open(file.name, 'wb') f.write(stderr) f.close() self.set_output(name, file) elif "string" == type: self.set_output(name, stderr) else: # pragma: no cover raise ValueError # create docstring d = """This module is a wrapper for the command line tool '%s'""" % \ conf['command'] # create module M = new_module(CLTools, tool_name, {"compute": compute, "conf": conf, "tool_name": tool_name, "__doc__": d}) reg = vistrails.core.modules.module_registry.get_module_registry() reg.add_module(M, package=identifiers.identifier, package_version=identifiers.version) def to_vt_type(s): # add recognized types here - default is String return '(basic:%s)' % \ {'file':'File', 'path':'Path', 'directory': 'Directory', 'flag':'Boolean', 'list':'List', 'float':'Float','integer':'Integer' }.get(s.lower(), 'String') # add module ports if 'stdin' in conf: name, type, options = conf['stdin']
f = open(file.name, 'wb') f.write(stderr) f.close() self.set_output(name, file) elif "string" == type: self.set_output(name, stderr) else: # pragma: no cover raise ValueError # create docstring d = """This module is a wrapper for the command line tool '%s'""" % \ conf['command'] # create module M = new_module(CLTools, tool_name, { "compute": compute, "conf": conf, "tool_name": tool_name, "__doc__": d }) reg = vistrails.core.modules.module_registry.get_module_registry() reg.add_module(M, package=identifiers.identifier, package_version=identifiers.version) def to_vt_type(s): # add recognized types here - default is String return '(basic:%s)' % \ {'file':'File', 'path':'Path', 'directory': 'Directory', 'flag':'Boolean', 'list':'List', 'float':'Float','integer':'Integer' }.get(s.lower(), 'String')