def handle_inout(tool, item_value, in_or_out): for ioD in item_value: # print(ioD) io_name = ioD['name'] if io_name is None: io_name = in_or_out _name = Preprocessor.io_name(io_name, onto) param_rdf = None if in_or_out == 'input': param = SagaInput(_name, prefLabel=locstr(io_name, lang='en')) # param = SagaInput(0,prefLabel=locstr(io_name, lang='en')) # blank node prefix with _: tool.input.append(param) param.isInput = True # rdflib param_rdf = URIRef(param.iri) with onto: g.add((param_rdf, RDF.type, Sh.NodeShape)) g.add((param_rdf, RDF.type, URIRef(SagaInput.iri))) else: param = SagaOutput(_name, prefLabel=locstr(io_name, lang='en')) # param =SagaOutput(0, prefLabel=locstr(io_name, lang='en')) tool.output.append(param) param.isOutput = True # rdflib param_rdf = URIRef(param.iri) with onto: g.add((param_rdf, RDF.type, Sh.NodeShape)) g.add((param_rdf, RDF.type, URIRef(SagaOutput.iri))) if ioD['dataType']: vr = re.match("[a-zA-Z ]+ (?=\([a-zA-Z ]+\))?", ioD['dataType']) dformat = vr.group().strip() if not get_format(dformat): continue param.supportsDataFormat.append(data[get_format(dformat)]) # rdflib formatshape = g.BNode() with onto: g.add((param_rdf, Sh.property, formatshape)) g.add((formatshape, RDF.type, Sh.PropertyShape)) g.add((formatshape, Sh.path, Cyber.supportsDataFormat)) formats = g.BNode() with onto: g.add((formats, RDF.first, [data[get_format(dformat)]])) g.add((formats, RDF.rest, RDF.nil)) c = Collection(g, formats) g.add((formatshape, Sh['in'], c)) param.identifier = ioD['name'] param.description.append(ioD['description']) param.flag = ioD['flag'] param.isOptional = ioD['isOptional'] OWLUtils.link_to_domain_concept(param, io_name.replace('_', ' ')) # shacl pshape = Sh.PropertyShape(0) pshape.path = onto.dataContent if not ioD['isOptional']: pshape.minCount = 1 pshape.message.append(ioD['name'] + " is required!")
def get_format(option): """ get mapping format 对应的数据格式 """ config = OWLUtils.get_config(module_path + '/config.ini') _prop = OWLUtils.get_option(config, 'format', option) return _prop
def topic_classes(): config = OWLUtils.get_config(module_path + '/config.ini') for k, v in config.items('application'): k = Preprocessor.to_upper_camel_case(k, True) topic_cls = OWLUtils.create_onto_class(onto, k, TopicCategoryTool) for _tool in v.split(','): _tool = _tool.strip() if onto[_tool] is not None: onto[_tool].is_a.append(topic_cls)
def handle_params(tool_param, param_item): # 具体参数 for itemK, itemV in param_item.items(): # 数据格式 if itemK == 'dataType' and get_format(itemV) is not None: tool_param.supportsDataFormat.append(data[get_format(itemV)]) tool_param.datatype.append(OWLUtils.get_datatype_iris(itemV)) _prop = get_property(itemK, DataProperty) if type(itemV) == list: itemV = ''.join(itemV) OWLUtils.set_data_property(tool_param, _prop, itemV)
def handle_applcation(): config = OWLUtils.get_config(module_path + '/config.ini') for k, v in config.items('application'): for _tool in v.split(','): _tool = _tool.strip() tools = [_tool] if str(_tool).endswith('*'): tools = onto.search(iri=module_uri + '#' + _tool) for __tool in tools: if onto[__tool] is not None: OWLUtils.application_category(onto[__tool], [], k, [])
def tool_class(category): # GIS Analysis => Distance Tools if re.match("(^GIS Analysis )", category): category = category.replace('GIS Analysis', '').strip() return OWLUtils.create_onto_class(onto, category.replace(' ', ''), onto['GISAnalysis']) if re.match("(^Image Processing Tools )", category): category = category.replace('Image Processing Tools', '').strip() return OWLUtils.create_onto_class(onto, category.replace(' ', ''), onto['ImageProcessingTools']) if category == 'Math and Stats Tools': category = "Math And Stats Tools" tool_cls = category.replace(' ', '') return OWLUtils.create_onto_class(onto, tool_cls, WhiteboxTool)
def map_to_owl(json_data): for d in json_data: """mapping json data to ontology properties""" # instance 实例 name = Preprocessor.name_underline(d['name']) toolClass = tool_class(d['name']) tool = toolClass(name, prefLabel=locstr(d['name'], lang='en')) tool.isToolOfSoftware.append(cyber.TauDEM) tool.identifier = name description = OWLUtils.join_list(d['description']) keywords = OWLUtils.to_keywords(description) keywords.extend(name.replace('_', ' ').split(' ')) # keywords=name.replace('_', ' ').split(' ') OWLUtils.link_to_domain_concept(tool, keywords) for k, v in d.items(): # 外层, 参数 if (k in ['parameters', 'options']) and type(v) == list: for i, item in enumerate(v): param = None # localname = v[i]['parameterName'] localname = Preprocessor.space_2_underline(item['parameterName']) _label = localname.replace('_', ' ') if item['isInputFile']: param = TauDEMInput(localname, prefLabel=locstr(_label, lang='en')) # param = TauDEMInput(prefLabel=locstr(_label, lang='en')) # input geo data ? rule: format-> geoformat->geo data tool.input.append(param) handle_params(param, item) param.isInput = True elif item['isOutputFile']: # localname.lower().startswith('output_', 0, len('output_')): param = TauDEMOutput(localname, prefLabel=locstr(_label, lang='en')) # param = TauDEMOutput(prefLabel=locstr(_label, lang='en')) tool.output.append(param) handle_params(param, item) param.isOutput = True else: param = TauDEMOption(localname, prefLabel=locstr(_label, lang='en')) # param = TauDEMOption(prefLabel=locstr(localname.replace('_', ' '), lang='en')) tool.option.append(param) handle_params(param, item) OWLUtils.link_to_domain_concept(param, _label) param.identifier = localname else: prop = get_property(k, DataProperty) if not v: continue if type(v) == list and len(v) > 0: v = ''.join(v) OWLUtils.set_data_property(tool, prop, v) # task handle_task(tool, name, d['name'], description) OWLUtils.application_category(tool, 'Geomorphometry', 'digital terrain analysis', 'hydrology')
def load_ontologies(): model_uri = 'http://www.egc.org/ont/process/test' onto = get_ontology(model_uri) onto, shacl, skos, dcterms, props, foaf = OWLUtils.load_common(onto) onto, geospatial = OWLUtils.load_geo_vocabl(onto) onto, gb, task, data, cyber = OWLUtils.load_common_for_process_tool(onto) onto, context = OWLUtils.load_context(onto) arcgis = get_ontology('arcgis.owl').load() grass = get_ontology('grass.owl').load(only_local=True) otb = get_ontology('otb.owl').load(only_local=True) saga = get_ontology('saga.owl').load(only_local=True) taudem = get_ontology('taudem.owl').load(only_local=True) whitebox = get_ontology('whitebox.owl').load(only_local=True) print('ontologies loaded') return onto, arcgis, grass, saga, otb, taudem, whitebox
def handle_task(tool, tool_name, en_str, _keywords, des): config = OWLUtils.get_config(module_path + '/config.ini') tasks = config.options('task') for task_item in tasks: # print(task_item) if task_item in _keywords: task_cls = config.get('task', task_item) # print(task_cls) short_name = tool_name.split('.', maxsplit=1)[0] task_name = config.get( 'tools', short_name) + '_' + tool_name.split('.', maxsplit=1)[1] task_name = task_name.replace('.', '_') # avoid duplicate if not task[task_name + "_task"]: task_ins = task[task_cls](task_name + "_task", prefLabel=locstr(en_str + " task", lang='en')) task_ins.description.append(locstr(des, lang='en')) task_ins.identifier = task_name task_ins.isAtomicTask = True else: task_ins = task[task_name + "_task"] if (task_ins in tool.usedByTask) is False: tool.usedByTask.append(task_ins) if (tool in tool.processingTool) is False: task_ins.processingTool.append(tool)
def get_task_class(tool_name): config = OWLUtils.get_config(module_path + '/config.ini') tool_cls = '' # only one for k, v in config.items('task'): if tool_name in v: tool_cls = k return tool_cls
def map_to_owl(json_data): """mapping json data to ontology properties""" tool_alsoes = [] for item in json_data: name = item['name'] if not name: continue if str(name).strip().find(' ') > 0: return # if str(name).strip().find(' ') > 0: continue # create or find tool class toolClass = tool_class(name) tool = toolClass(name, prefLabel=locstr(name, lang='en')) # tool = GrassTool(name, prefLabel=locstr(name, lang='en')) tool.isToolOfSoftware.append(cyber.GRASS_GIS) tool.identifier = name tool.manualPageURL.append(item['manual_url']) if 'addons' in item['manual_url']: tool.isAddon = True tool.description.append(locstr(item['description'], lang='en')) if item['source_code']: tool.sourceCodeURL.append(item['source_code']) tool.comment.append(item['notes']) tool.authors.append(OWLUtils.join_keywords(item['authors'])) tool.definition.append(item['definition']) keywords = item['keywords'] # tool.keywords.append(OWLUtils.join_keywords(item['keywords'])) # tool.subject.append(OWLUtils.join_keywords(item['keywords'])) # keywords and name # keywords.extend(name.split('.')[1:]) OWLUtils.link_to_domain_concept(tool, keywords) tool.commandLine.append(item['synopsis']) r = re.match('[a-z.]+ ', item['synopsis']) if r: tool.executable = str(r.group()).strip() see_also_items = {} for also in item['see_also']: if '.' not in also: continue see_also_items[tool] = [also] tool_alsoes.append(see_also_items) for parameter in item['parameters']: handle_parameters(tool, parameter, onto) handle_task(tool, name, name, item['keywords'], item['description']) handle_also(tool_alsoes) handle_applcation() topic_classes()
def handle_options(tool, param, _onto): pname = param['name'] _name = Preprocessor.io_name(pname, _onto, common_options) p = GDALOption(_name, prefLabel=locstr(pname, lang='en')) p.identifier = pname if param['flag']: p.flag = param['flag'] p.isOptional = param['isOptional'] p.description.append(locstr(param['explanation'], lang='en')) p.datatype.append(OWLUtils.get_datatype_iris(param['dataType'])) if "available_values" in param.keys(): for value in param['available_values']: p.availableValue.append(value) onto, _list = OWLUtils.resources_2_rdf_list(_onto, param['available_values']) p.availableList.append(_list) if "available_choices" in param.keys(): p, onto = OWLUtils.handle_choices(p, pname, param['available_choices'], GDALAvailableChoice, _onto) if "input_pattern" in param.keys(): p.inputPattern.append(param['input_pattern']) tool.option.append(p)
def get_property(option, prop_type): """ 根据配置查找对应的属性,没有则创建新的属性 Args: option: property name prop_type: ObjectProperty or DataProperty Returns: created property name """ config = OWLUtils.get_config(module_path + '/config.ini') _prop = OWLUtils.get_option(config, 'saga', option) if _prop is None: if onto.__getattr__(option) is None: OWLUtils.create_onto_class(onto, option, prop_type) return option else: return _prop
def tool_class(name): if str(name).startswith('gnm'): tool_cls = "GeographicNetworkPrograms" elif str(name).startswith('ogr'): tool_cls = "VectorPrograms" elif str(name).startswith('gdalmd'): tool_cls = "MultidimensionalRasterPrograms" else: tool_cls = "RasterPrograms" return OWLUtils.create_onto_class(onto, tool_cls, GDALTool)
def handle_parameter(tool, param): pname = param['name'] p = None _name = Preprocessor.io_name(pname, onto, common_options) if 'isInputFile' in param.keys(): p = GDALInput(_name, prefLabel=locstr(pname, lang='en')) p.isInput = True tool.input.append(p) OWLUtils.link_to_domain_concept(p, pname.replace('_', ' ')) elif "isOutputFile" in param.keys(): p = GDALOutput(_name, prefLabel=locstr(pname, lang='en')) p.isOutput = True tool.output.append(p) OWLUtils.link_to_domain_concept(p, pname.replace('_', ' ')) p.identifier = pname if param['flag']: p.flag = param['flag'] p.isOptional = param['isOptional'] p.description.append(locstr(param['explanation'], lang='en')) p.datatype.append(OWLUtils.get_datatype_iris(param['dataType']))
def handle_options(tool, option, _onto): name = option['name'] if name is None: name = 'option' _name = Preprocessor.io_name(Preprocessor.name_underline(name), _onto) op = SagaOption(_name, prefLabel=locstr(name, lang='en')) tool.option.append(op) if option['description'] != '-': op.description = option['description'] op.flag = option['flag'] op.identifier = name constraints = option['constraints'] # shacl pshape = Sh.PropertyShape(0) pshape.path.append(_onto.dataContent) if constraints: if 'fields_des' in constraints.keys() and constraints['fields_des']: op.description.append(constraints['fields_des']) else: if 'minimum' in constraints.keys() and constraints['minimum']: op.minimum = constraints['minimum'] pshape.minExclusive = constraints['minimum'] if 'defaultValue' in constraints.keys( ) and constraints['defaultValue']: op.defaultValue = constraints['defaultValue'] pshape.defaultValue = constraints['defaultValue'] if 'maximum' in constraints.keys() and constraints['maximum']: op.maximum = constraints['maximum'] pshape.maxInclusive = constraints['maximum'] op.datatypeInString.append(option['dataType']) pshape.datatype = [OWLUtils.get_datatype_iris(option['dataType'])] op.datatype.append(OWLUtils.get_datatype_iris(option['dataType'])) if 'availableChoices' in constraints.keys( ) and constraints['availableChoices']: c = [] for achoice in constraints['availableChoices']: c.append(achoice['choice']) with _onto: g.add((pshape, Sh['in'], c)) OWLUtils.handle_choices(op, name, constraints['availableChoices'], SagaAvailableChoice, _onto)
def map_to_owl(json_data): for d in json_data: toolClass = tool_class(d['category']) name = Preprocessor.toolname_underline(d['title']) tool = toolClass(name, prefLabel=locstr(d['title'], lang='en')) tool.isToolOfSoftware.append(cyber.Whitebox_Tools) tool.identifier = name tool.manualPageURL.append('https://github.com/jblindsay/whitebox-tools/blob/master/manual/WhiteboxToolsManual.md') tool.executable = 'whitebox_tools' tool.commandLine.append(d['parameter_commandline'][0]) tool.description.append(locstr(d['description'], lang='en')) keywords = OWLUtils.to_keywords(d['description']) keywords.extend(d['title'].split(" ")) OWLUtils.link_to_domain_concept(tool, keywords) handle_task(tool, d['category'], d['title'], d['description']) OWLUtils.application_category(tool, [], d['category'].replace(' Tools', ''), []) for parameter in d['parameter']: handle_parameter(tool, parameter)
def get_property(option, prop_type): """ 根据配置查找对应的属性,没有则创建新的属性 Args: option: property name prop_type: ObjectProperty or DataProperty Returns: created property name """ config = OWLUtils.get_config(module_path + '/config.ini') _prop = OWLUtils.get_option(config, 'taudem', option) # 返回配置的属性或是已有的属性(has[Name]) if _prop is not None: return _prop else: _prop = gb.__getattr__(option) if _prop is None: OWLUtils.create_onto_class(onto, option, prop_type) return option
def map_to_owl(json_data): for d in json_data: name = d['name'] toolClass = tool_class(name) name = Preprocessor.space_2_underline(name) tool = toolClass(name, prefLabel=locstr(name, lang='en')) tool.isToolOfSoftware.append(cyber.GDAL) tool.identifier = name tool.definition = d['summary'] tool.manualPageURL.append(d['manual_url']) tool.executable = d['exec'] tool.commandLine.append(d['syntax']) tool.description.append(locstr(d['description'], lang='en')) OWLUtils.application_category(tool, [], ['GIS Analysis'], [str(toolClass.name).replace('Programs', '')]) keywords = OWLUtils.to_keywords(d['description']) OWLUtils.link_to_domain_concept(tool, keywords) for example in d['example']: tool.example.append(example) handle_task(tool, d['name'], d['description']) for parameter in d['parameters']: handle_parameter(tool, parameter) for option in d['options']: handle_options(tool, option, onto)
def map_to_owl(json_data): for d in json_data: """mapping json data to ontology properties""" name = re.match("[0-9a-zA-Z\-/* ]+ (?=\([\w' ]+\))", d['name']) # 存在同名冲突 if name: name_str = name.group().strip().lower().replace(' ', '_').replace( '/', '_') else: continue category = get_task_type(d['name']) toolCls = tool_class(category) # if already exists a instance has the same name if onto[name_str]: # if is the same if onto[name_str].syntax == d['syntax']: onto[name_str].is_a.append(toolCls) continue else: name_str = name_str + '_' + category.lower().replace(' ', '_') tool = toolCls(name_str, prefLabel=locstr(name_str.replace('_', ' '), lang='en')) keywords = [name_str.replace('_', ' ')] OWLUtils.link_to_domain_concept(tool, keywords) tool.isToolOfSoftware.append(cyber.ArcGIS_Desktop) tool.identifier = name_str.replace('_', ' ') # tool.hasManualPageURL.append(d['manual_url']) tool.description.append(locstr(d['description'], lang='en')) tool.usage.append(OWLUtils.join_list(d['usage'])) tool.syntax.append(d['syntax']) tool.example.append(handle_example(d['example'])) handle_task(tool, d['name'], name_str, d['description']) for parameter in d['parameters']: handle_parameters(tool, parameter)
def map_to_owl(json_data): for d in json_data: """mapping json data to ontology properties""" name = Preprocessor.toolname_underline(d['name']) # name = re.sub("[()-*,/]", " ", name).strip() executable = Preprocessor.normalize("saga_cmd ", d['command']['exec']) keywords = d['keywords'] toolClass = tool_class(keywords) if onto[name]: # if has the same name and executable if onto[name].executable == executable: onto[name].is_a.append(toolClass) continue else: name = name + '_' + keywords[0].replace(' ', '_') tool = toolClass(name, prefLabel=locstr(re.sub('^(Tool)[0-9: ]+', '', d['name']), lang='en')) # tool = toolClass(Preprocessor.space_2_underline(name), prefLabel=locstr(re.sub('^(Tool)[0-9: ]+', '', d['name']), lang='en')) tool.isToolOfSoftware.append(cyber.SAGA_GIS) tool.identifier = name tool.manualPageURL.append(d['manual_url']) # task handle_task(tool, name, d['name'], keywords, OWLUtils.join_list(d['description'])) tool.executable = executable tool.commandLine.append( Preprocessor.normalize("Usage: ", d['command']['cmd_line'])) tool.authors.append(OWLUtils.join_keywords(d['authors'])) for reference in d['references']: tool.references.append(reference) # keywords keywords.append(name.replace('_', ' ')) OWLUtils.link_to_domain_concept(tool, keywords) # applicaiton category OWLUtils.application_category(tool, [d['keywords'][0]], d['keywords'][1], d['keywords'][2:]) tool.description.append(OWLUtils.join_list(d['description'])) if d['parameters']: for item, itemValue in d['parameters'].items(): if item == 'inputs': handle_inout(tool, itemValue, 'input') elif item == 'outputs': handle_inout(tool, itemValue, 'output') elif item == 'options': for optionItem in itemValue: handle_options(tool, optionItem, onto)
def handle_task(tool, task_name, des): config = OWLUtils.get_config(module_path + '/config.ini') category = tool_class(task_name) task_cls = config.get('task', category.name) task_name = Preprocessor.space_2_underline(task_name.replace(".py", "")) if not task[task_name + "_task"]: task_ins = task[task_cls](task_name + "_task", prefLabel=locstr(task_name + " task", lang='en')) task_ins.isAtomicTask = True task_ins.identifier = task_name else: task_ins = task[task_name + "_task"] if (task_ins in tool.usedByTask) is False: tool.usedByTask.append(task_ins) if (tool in tool.processingTool) is False: task_ins.processingTool.append(tool) task_ins.description.append(locstr(des, lang='en'))
def handle_parameters(tool, param): # 部分parameter不包含isInputFile等属性 _name = Preprocessor.io_name(param['name'], onto) if 'isInputFile' in param.keys() and param['isInputFile']: p = ArcGISInput(_name, prefLabel=locstr(param['name'], lang='en')) # p = ArcGISInput(0, prefLabel=locstr(param['name'], lang='en')) tool.input.append(p) p.isInput = param['isInputFile'] OWLUtils.link_to_domain_concept(p, param['name'].replace('_', ' ')) elif 'isOutputFile' in param.keys() and param['isOutputFile']: p = ArcGISOutput(_name, prefLabel=locstr(param['name'], lang='en')) # p = ArcGISOutput(0, prefLabel=locstr(param['name'], lang='en')) tool.output.append(p) p.isOutput = param['isOutputFile'] OWLUtils.link_to_domain_concept(p, param['name'].replace('_', ' ')) else: p = ArcGISOption(_name, prefLabel=locstr(param['name'], lang='en')) # p = ArcGISOption(0, prefLabel=locstr(param['name'], lang='en')) tool.option.append(p) dt = param['dataType'] if dt: p.datatypeInString.append(param['dataType']) p.datatype.append(OWLUtils.get_datatype_iris(param['dataType'])) OWLUtils.link_to_domain_concept(p, param['name'].replace('_', ' ')) p.identifier = param['name'] p.flag = param['name'] if 'dataType' in param.keys() and param['dataType']: p.datatypeInString.append(param['dataType']) p.description.append(param['description']) p.isOptional = param['isOptional'] # datatype datatype = param['dataType'] if datatype is None: datatype = "string" dt = datatype.strip().lower().replace(' ', '_') # print(dt) dtype = data[dt] if dtype is None: dtype = OWLUtils.get_datatype_iris(dt) p.datatype.append(dtype) if "available_values" in param.keys(): for value in param['available_values']: p.availableValue.append(value)
def handle_task(tool, category, task_name, des): config = OWLUtils.get_config(module_path + '/config.ini') if re.match("(^GIS Analysis )", category): category = 'GIS Analysis' elif re.match("(^Image Processing Tools )", category): category = 'Image Processing Tools' task_cls = config.get('task', category) i_task_name = task_name.replace(' ', '_') if not task[i_task_name + "_task"]: task_ins = task[task_cls](i_task_name + "_task", prefLabel=locstr(task_name + " task", lang='en')) task_ins.isAtomicTask = True task_ins.identifier = i_task_name else: task_ins = task[i_task_name + "_task"] if (task_ins in tool.usedByTask) is False: tool.usedByTask.append(task_ins) if (tool in tool.processingTool) is False: task_ins.processingTool.append(tool) task_ins.description.append(locstr(des, lang='en'))
def handle_parameters(tool, param, _onto): # 部分parameter不包含isInputFile等属性 name = param['parameter'] _name = Preprocessor.io_name(param['parameter'], _onto, ['overwrite']) if 'isInputFile' in param.keys() and param['isInputFile']: p = GrassInput(_name, prefLabel=locstr(name, lang='en')) # p = GrassInput(0, prefLabel=locstr(name, lang='en')) tool.input.append(p) p.isInput = param['isInputFile'] OWLUtils.link_to_domain_concept(p, name.replace('_', ' ')) elif 'isOutputFile' in param.keys() and param['isOutputFile']: p = GrassOutput(_name, prefLabel=locstr(name, lang='en')) # p = GrassOutput(0, prefLabel=locstr(name, lang='en')) tool.output.append(p) p.isOutput = param['isOutputFile'] OWLUtils.link_to_domain_concept(p, name.replace('_', ' ')) else: p = GrassOption(_name, prefLabel=locstr(name, lang='en')) # p = GrassOption(0, prefLabel=locstr(name, lang='en')) tool.option.append(p) p.flag = param['flag'] p.identifier = name if 'dataType' in param.keys(): p.datatypeInString.append(param['dataType']) p.datatype.append(OWLUtils.get_datatype_iris(param['dataType'])) p.description.append(param['explanation']) if 'defaultValue' in param.keys(): if param['defaultValue'] is not None: p.defaultValue = param['defaultValue'] p.isOptional = param['isOptional'] if 'alternatives' in param.keys(): alternatives = param['alternatives'] if alternatives: literal = True if param['explanation'] == "Name of Modules": literal = False if len(alternatives) > 1: _onto, l = OWLUtils.resources_2_rdf_list( _onto, alternatives, literal) p.availableList.append(l) for value in alternatives: p.availableValue.append(value) else: if re.match('[-0-9]+-[0-9]+', alternatives[0]): p.minimum = alternatives[0].rsplit('-', 1)[0] p.maximum = alternatives[0].rsplit('-', 1)[1] elif re.match('[-0-9]+-[a-zA-Z<> ]+', alternatives[0]): p.minimum = alternatives[0].split('-')[0] p.comment.append('Options: ' + ' '.join(alternatives))
def handle_task(tool, full_name, task_name, des): config = OWLUtils.get_config(module_path + '/config.ini') task_type = get_task_type(full_name) task_cls = config.get('task', task_type) # tool.keywords.append(task_type) tool.subject.append(task_type) # avoid duplicate if not task[task_name + "_task"]: task_ins = task[task_cls](task_name + "_task", prefLabel=locstr( task_name.replace('_', ' ') + " task", lang='en')) task_ins.isAtomicTask = True task_ins.identifier = task_name else: task_ins = task[task_name + "_task"] if (task_ins in tool.usedByTask) is False: tool.usedByTask.append(task_ins) if (tool in tool.processingTool) is False: task_ins.processingTool.append(tool) task_ins.description.append(locstr(des, lang='en'))
def handle_task(tool, tool_name, en_str, _keywords, desc): config = OWLUtils.get_config(module_path + '/config.ini') tasks = config.options('task') for task_item in tasks: # print(task_item) if task_item in _keywords: task_cls = config.get('task', task_item) task_name = Preprocessor.task_name(tool_name) if task[task_name] is None: task_ins = task[task_cls]( task_name, prefLabel=locstr(en_str.replace('Tool', '') + " task", lang='en')) # task_ins = task[task_cls](tool_name + "_task", prefLabel=locstr(en_str.replace('Tool', '') + " task", lang='en')) task_ins.description.append(locstr(desc, lang='en')) task_ins.isAtomicTask = True task_ins.identifier = task_name else: task_ins = task[task_name] if (task_ins in tool.usedByTask) is False: tool.usedByTask.append(task_ins) if (tool in tool.processingTool) is False: task_ins.processingTool.append(tool)
def handle_parameter(tool, param): # p = None dformat = file_type(param['flag'], tool.commandLine[0]) ptype = param_type(param['description']) if 'flag_long' in param.keys(): pname = param['flag_long'].replace('--', '') else: pname = param['flag'].replace('--', '') _name = Preprocessor.io_name(pname, onto) if ptype == 1: p = WhiteboxInput(_name, prefLabel=locstr(pname, lang='en')) # p = OTBInput(0, prefLabel=locstr(param['name'], lang='en')) tool.input.append(p) p.isInput = True OWLUtils.link_to_domain_concept(p, pname.replace('_', ' ')) elif ptype == 2: p = WhiteboxOutput(_name, prefLabel=locstr(pname, lang='en')) # p = OTBOutput(0, prefLabel=locstr(param['parameter_name'], lang='en')) tool.output.append(p) p.isOutput = True OWLUtils.link_to_domain_concept(p, pname.replace('_', ' ')) elif ptype == 3: p = WhiteboxOption(_name, prefLabel=locstr(pname, lang='en')) tool.option.append(p) p.isOptional = True OWLUtils.link_to_domain_concept(p, pname.replace('_', ' ')) else: p = WhiteboxOption(_name, prefLabel=locstr(pname, lang='en')) tool.option.append(p) avaliable_choices(p, param['description']) if dformat: p.supportsDataFormat = dformat p.identifier = pname p.flag = param['flag'] if 'flag_long' in param.keys(): p.longFlag.append(param['flag_long']) p.description.append(locstr(param['description'], lang='en'))
onto.metadata.created.append(datetime.datetime.today()) print('ontologies imported') # OWLUtils.create_onto_class(onto, 'has' + option.capitalize(), prop_type) with onto: class GeoTerms(Thing): pass module_path = os.path.dirname(__file__) with open(module_path + '/term.json', 'r', encoding='utf-8') as f: jdata = json.load(f) # list for d in jdata: domain = d['domain'] if not onto[domain]: OWLUtils.create_onto_class(onto, domain, GeoTerms) term = d['term'] term_english = d['term_english'] definition_cn = d['definition'] if onto[term] and (GeoTerms in onto[term].is_a): # 不能用definition? onto[domain].definition.append(definition_cn) else: indi = onto[domain](term, prefLabel=locstr(term_english, lang='en'), altLabel=locstr(term, lang='zh-CN')) print(onto[domain]) print(indi) indi.definition.append(definition_cn) # onto.save("geoterms.owl", format="rdfxml")
def tool_class(keywords): tool_cls = keywords[0].replace(' ', '') + 'Tool' return OWLUtils.create_onto_class(onto, tool_cls, SagaTool)