def __init__(self, peptidoform_string=None, verbose=None): self.peptidoform_string = None self.peptide_sequence = None self.residue_modifications = {} self.terminal_modifications = {} self.unlocalized_mass_modifications = {} self.neutral_mass = None self.response = Response() self.is_valid = False if len(ontologies) == 0: #print("Loading ontologies...", end='', flush=True) #ontologies['UNIMOD'] = Ontology(filename='G:/Repositories/SVN/proteomics/var/CV/unimod.obo') #ontologies['PSI-MOD'] = Ontology(filename='G:/Repositories/SVN/proteomics/var/CV/PSI-MOD.obo') ontologies['UNIMOD'] = Ontology( filename= '/net/dblocal/wwwspecial/proteomecentral/extern/CVs/unimod.obo' ) ontologies['PSI-MOD'] = Ontology( filename= '/net/dblocal/wwwspecial/proteomecentral/extern/CVs/PSI-MOD.obo' ) #print(" done.") if peptidoform_string: self.parse(peptidoform_string, verbose=None)
def main(): if (sys.argv[-1] == '--collect'): url_pois = 'https://pt.foursquare.com/explore?mode=url&ne=-29.358988%2C-50.837817&q=Sele%C3%A7%C3%B5es%20principais&sw=-29.41889%2C-50.887942' url_city = 'http://www.dataviva.info/pt/location/5rs020102' e = Extraction(url_pois, url_city) e.poi_data_extraction() e.city_data_extraction() # Gera relatório do dataset file = 'foursquare_data.csv' df = pd.read_csv(file, parse_dates=True, encoding='UTF-8') profile = pandas_profiling.ProfileReport(df) profile.to_file(outputfile='dataset_report.html') P = Process(file) df = P.method() df_report = pd.read_csv('preprocessed.csv', parse_dates=True, encoding='UTF-8') profile = pandas_profiling.ProfileReport(df_report) profile.to_file(outputfile='preprocessed_dataset_report.html') R = Recommendation(df) R.pattern_recommendation() R.new_recommendation() R.compare() # R.test_rec() ont = Ontology() ont.write_owl()
def decode_resource_path(self, path): result = None if path: decoded = Ontology(self.env, 'ns.medium.resource.url.decode') decoded['directory'], decoded['file name'] = os.path.split(path) if 'file name' in decoded and 'directory' in decoded: # Normalize the directory # This will replace path framents with canonic values decoded['directory'] = self.normalize(decoded['directory']) # Check if the directory resides in a volume for volume in self.volume.element.values(): if os.path.commonprefix((volume.node['real'], decoded['directory'])) == volume.node['real']: decoded['volume'] = volume.key # If a UMID was encoded in the name, infer the home id and media kind # This will also trigger rule.medium.resource.filename.parse if 'umid' in decoded: umid = Umid.decode(decoded['umid']) if umid: decoded['media kind'] = umid.media_kind decoded['home id'] = umid.home_id # Make the elements of the decoded onlology kernel elements of the result result = decoded.project('ns.medium.resource.location') for k,v in decoded.iteritems(): result[k] = v # set the host and domain result['host'] = self.host result['domain'] = self.domain return result
def parse(oboFile, typedefs): """ Parses an OBO (ontology file) creating a correspoinding Ontology object composed of Term objects that relate to the terms found in the ontology file. """ ontology = Ontology() ## Use groupby to group the lines of our file into chunks of text, some ## stanzas, some typedefs, and other metadata to be processed with open(oboFile) as f: for (key, group) in groupby(f, is_data): if key: header = group.next().rstrip('\n') if header.find('[Typedef]') != -1: dataDict = get_data_as_dict(group) ontology.add_typedef(dataDict['name']) elif header.find('[Term]') != -1: dataDict = get_data_as_dict(group, typedefs) ontology.add_term(build_term(dataDict)) else: # We are dealing with ontology metadata that should be # captured in our ontology object. ontology.metadata.append(header) ontology.metadata.extend([x.strip() for x in group]) return ontology
def po_example(): ontology = Ontology(filename='plant-ontology.obo', verbose=1) ontology.show() print("============================") name = 'xyl' result_list = ontology.fuzzy_search(search_string=name) for item in result_list: print(item)
def test_TasksReader(self): '''test Tasks.TaskReader() ''' reload( Ontology.FlatOntologyManager ) # since this has a singleton class - may be called by other nosetests earlier Ontology.init_global_ontology() task_reader = Tasks.TaskReader(taskfile=self.taskfile) task_reader.get_task_by_id(task_id=10001) task_reader.get_random_task()
def set(self): genealogy = Ontology(self.env, 'ns.service.genealogy', self.document['head']['genealogy']) genealogy.merge_all(self.ontology['genealogy']) self.document['head']['genealogy'] = genealogy.node # persist document self.env.resolver.save(self.document) # refetch the document self.document = self.env.resolver.resolve(self.uri, self.ontology['query'])
def test_TasksCreator(self): '''test Tasks.TaskCreator() ''' reload( Ontology.FlatOntologyManager ) # since this has a singleton class - may be called by other nosetests earlier Ontology.init_global_ontology() task_generator = Tasks.TaskCreator() task_generator._create() task_generator._write()
def test_simulate_multidomain(self): '''Run HDC policy for domains in 2 multi domain dialogues ''' Settings.init(config_file='./tests/test_configs/simulate_multiDomains_HDC.cfg') ContextLogger.createLoggingHandlers(config=Settings.config) logger = ContextLogger.getLogger('') logger.info("Starting HDC Multidomain Simulation") reload(Ontology.FlatOntologyManager) # since this has a singleton class Ontology.init_global_ontology() simulator = Simulate.SimulationSystem(error_rate=0.1) simulator.run_dialogs(2) # run 2 dialogues
def parse(self, query): for source in query["sources"]: try: document = json.load(source) except ValueError as e: self.log.warning(u"Failed to decode JSON document %s", query["remote url"]) self.log.debug(u"Exception raised %s", unicode(e)) else: if "process" in query["branch"]: action = getattr(self, query["branch"]["process"], None) if action is not None: document = action(query, document) else: self.log.warning(u"Ignoring unknown process function %s", query["branch"]["process"]) if query["branch"]["query type"] == "lookup": entry = { "branch": query["branch"], "record": { u"head": {u"genealogy": query["parameter"].project("ns.service.genealogy")}, u"body": {u"original": document}, }, } if "namespace" in query["branch"]: # make a caonical node entry["record"]["body"]["canonical"] = Ontology(self.env, entry["branch"]["namespace"]) entry["record"]["body"]["canonical"].decode_all(entry["record"]["body"]["original"], self.name) # Copy indexed values from the canonical node to the genealogy if "index" in entry["branch"]: for index in entry["branch"]["index"]: if index in entry["record"]["body"]["canonical"]: entry["record"][u"head"][u"genealogy"][index] = entry["record"]["body"][ "canonical" ][index] # Append the entry to the query result query["entires"].append(entry) elif query["branch"]["query type"] == "search": for trigger in query["branch"]["resolve"]: for element in document[query["branch"]["container"]]: # Decode a reference o = Ontology(self.env, trigger["namespace"]) o.decode_all(element, self.name) # Make a URI and trigger a resolution ref = o.project("ns.service.genealogy") ref["language"] uri = trigger["format"].format(**ref) self.log.debug(u"Trigger %s resolution", uri) self.resolver.resolve(uri)
def test_simulate_multidomain(self): '''Run 2 dialogues with the multidomain system and GP policies (NB: config needs to explicitly set each domain to use gp actually...) ''' Settings.init(config_file='./tests/test_configs/simulate_multiDomains_GP.cfg') ContextLogger.createLoggingHandlers(config=Settings.config) logger = ContextLogger.getLogger('') logger.info("Starting GP Multidomain Simulation") reload(Ontology.FlatOntologyManager) # since this has a singleton class Ontology.init_global_ontology() simulator = Simulate.SimulationSystem(error_rate=0.1) simulator.run_dialogs(2) # run 2 dialogues
def test_simulate_singledomain_for_all_domains(self): '''Loop over all domains and runs 2 dialogues with GP policy in each ''' import numpy.random as nprand # not seeding this - so will be based on system clock--> meaning TESTING here will be somewhat random --> # NOTE --> THIS IS !!!REALLY REALLY REALLY!!! NOT IN THE SPIRIT OF (UNIT) TESTING - WHICH SHOULD NEVER BE ~RANDOM # doing it to get a little more coverage of testing without writing permutations of explicit tests ... Settings.init( config_file= './tests/test_configs/simulate_singledomain_for_all_domains.cfg') ContextLogger.createLoggingHandlers(config=Settings.config) logger = ContextLogger.getLogger('') domains = TestingUtils.get_loop_over_domains() for dstring in domains: Settings.config.set("GENERAL", 'domains', dstring) logger.info("Starting GP Single Domain Simulation for " + dstring) # [policy_DOMAINTAG] Settings.config.add_section('policy_' + dstring) Settings.config.set('policy_' + dstring, 'learning', 'True') Settings.config.set('policy_' + dstring, 'policytype', 'gp') # no inpolicy file give --> starts with empty file (random policy) Settings.config.set('policy_' + dstring, 'outpolicyfile', 'tests/test_gp/' + dstring) if nprand.uniform() > 0.5: Settings.config.set('policy_' + dstring, 'belieftype', 'baseline') else: Settings.config.set('policy_' + dstring, 'belieftype', 'focus') # [gppolicy_DOMAINTAG] Settings.config.add_section('gppolicy_' + dstring) if nprand.uniform() > 0.5: Settings.config.set('gppolicy_' + dstring, 'kernel', 'polysort') else: Settings.config.set('gppolicy_' + dstring, 'kernel', 'gausssort') if nprand.uniform() > 0.5: Settings.config.set('gppolicy_' + dstring, 'actionkerneltype', 'delta') else: Settings.config.set('gppolicy_' + dstring, 'actionkerneltype', 'hdc') reload(Ontology.FlatOntologyManager ) # since this has a singleton class Ontology.init_global_ontology() simulator = Simulate.SimulationSystem(error_rate=0.1) simulator.run_dialogs(2) # run 2 dialogues
def test_simulate_singledomain_for_all_domains(self): '''Loop over all domains and run 2 dialogues via HDC policy in each ''' Settings.init(config_file='./tests/test_configs/simulate_singledomain_for_all_domains.cfg') ContextLogger.createLoggingHandlers(config=Settings.config) logger = ContextLogger.getLogger('') domains = TestingUtils.get_loop_over_domains() for dstring in domains: Settings.config.set("GENERAL", 'domains', dstring) # no policy settings given --> defaults to HDC logger.info("Starting HDC Single Domain Simulation for "+dstring) reload(Ontology.FlatOntologyManager) # since this has a singleton class Ontology.init_global_ontology() simulator = Simulate.SimulationSystem(error_rate=0.1) simulator.run_dialogs(2) # run 2 dialogues
def _load_mediainfo(self): command = self.env.initialize_command("mediainfo", self.log) if command: command.extend([u"--Language=raw", u"--Output=XML", u"--Full", self.ontology["path"]]) proc_mediainfo = Popen(command, stdout=PIPE, stderr=PIPE) proc_grep = Popen([u"grep", u"-v", u"Cover_Data"], stdin=proc_mediainfo.stdout, stdout=PIPE) raw_xml = proc_grep.communicate()[0] # parse the DOM element = ElementTree.fromstring(raw_xml) if element is not None: for node in element.findall(u"File/track"): if "type" in node.attrib: mtype = self.env.enumeration["mediainfo stream type"].search(node.attrib["type"]) if mtype is not None: if mtype.node["namespace"]: # initialize an ontology with the correct namespace o = Ontology(self.env, mtype.node["namespace"]) # iterate over the properties and populate the ontology for item in list(node): text = item.text # decode base64 encoded element if "dt" in item.attrib and item.attrib["dt"] == "binary.base64": text = base64.b64decode(text) text = unicode(text, "utf8") # set the concept on the ontology o.decode(item.tag, text) # fix the video encoder settings on video tracks if mtype.key == "video": self._fix_mediainfo_encoder_settings(o) # add the ontology to the stream stack self._execution["crawl"]["stream"].append(o) elif mtype.key == "menu": menu = Menu(self.env) for item in list(node): menu.add(Chapter.from_raw(item.tag, item.text, Chapter.MEDIAINFO)) menu.normalize() if menu.valid: self._execution["crawl"]["menu"].append(menu) # Release resources held by the element, we no longer need it element.clear()
def _run(self): """ Runs the build process to produce the ontology documentation. """ fileoutinfos = self.getOutputFileInfos() # Create the destination directory, if needed. We only need to check # this for in-source builds, since the BuildDirTarget dependency will # take care of this for out-of-source builds. if self.config.getDoInSourceBuilds(): destdir = os.path.dirname(fileoutinfos[0].destpath) if not (os.path.isdir(destdir)): self._makeDirs(destdir) logger.info('Creating ontology documentation files...') ont = Ontology(self.mobt_reasoned.getOutputFilePath()) # Create the documentation files. for foutinfo in fileoutinfos: # If the format is HTML, make sure the supporting CSS and # Javascript files are present. if foutinfo.formatstr == 'html': destdir = os.path.dirname(foutinfo.destpath) self._checkWebFiles(['documentation_styles.css', 'navtree.js'], destdir) writer = getDocumentationWriter(foutinfo.formatstr) documenter = Documenter(ont, writer) with open(self.config.getDocSpecificationFile()) as docspec: with open(foutinfo.destpath, 'w') as fout: documenter.document(docspec, fout)
def transform(self, template): # apply overrides on the pivot location from the template if 'override' in template: for k,v in template['override'].iteritems(): self.location[k] = v # apply track rules from the template if 'track' in template: for rule in template['track']: for branch in rule['branch']: taken = False for stream in self.resource.stream: if stream.match(branch): taken = True s = Ontology.clone(stream) s['resource path digest'] = self.resource.location['path digest'] if 'override' in rule: for k,v in rule['override'].iteritems(): s[k] = v self.stream.append(s) if rule['mode'] == 'choose': break if taken and rule['mode'] == 'choose': break return self.taken
def _transcode_ac3(self, task): product = task.produce(task.ontology) if product: taken = False for pivot in task.transform.pivot.values(): for stream in pivot.stream: if not taken and stream['stream kind'] == 'audio': taken = True # Clone the hint ontology product.hint = Ontology.clone(self.hint) command = self.env.initialize_command('ffmpeg', self.log) if command: # make ffmpeg not check for overwrite, we already do this check command.append(u'-y') # set the number of processing threads command.append(u'-threads') command.append(unicode(self.env.system['threads'])) # set the input file command.append(u'-i') command.append(self.path) for k,v in stream['ffmpeg parameters'].iteritems(): command.append(k) if v is not None: command.append(unicode(v)) if taken: break if taken and self.env.check_path_available(product.path, task.ontology['overwrite']): command.append(product.path) message = u'Transcode {} --> {}'.format(self.path, product.path) self.env.execute(command, message, task.ontology['debug'], pipeout=True, pipeerr=False, log=self.log)
def init(_boardname=None): global player, game name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer1' #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer2' #NON #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer3' #name = _boardname if _boardname is not None else '10x10' #name = _boardname if _boardname is not None else 'Lab_15x15' #NON #name = _boardname if _boardname is not None else 'map' #NON #name = _boardname if _boardname is not None else 'map2' #NON #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer_6x6' #NON #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer_bomberman' #YES #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer_impossible' #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer_incroyable' #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer_labyrinthe2' #name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer_labyrinthe3' #NON #name = _boardname if _boardname is not None else 'thirst' #NON game = Game('Cartes/' + name + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = 20 # frames per second game.mainiteration() game.mask.allow_overlaping_players = True
def init(_boardname=None): global player, game name = _boardname if _boardname is not None else 'pathfindingWorld_multiPlayer' game = Game('Cartes/' + name + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = 5 # frames per second game.mainiteration()
def _run(self): """ Runs the build process and produces a new, modified version of the main OWL ontology file. """ timer = BasicTimer() timer.start() self._retrieveAndCheckFilePaths() mainont = Ontology(self.obt.getOutputFilePath()) if self.mergeimports: # Merge the axioms from each imported ontology directly into this # ontology (that is, do not use import statements). logger.info( 'Merging all imported ontologies into the main ontology...') for importIRI in mainont.getImports(): mainont.mergeOntology(importIRI, self.config.getAnnotateMerged()) if self.prereason: logger.info('Running reasoner and adding inferred axioms...') inf_types = self.config.getInferenceTypeStrs() annotate_inferred = self.config.getAnnotateInferred() preprocess_inverses = self.config.getPreprocessInverses() iaa = InferredAxiomAdder(mainont, self.config.getReasonerStr()) if self.config.getExcludedTypesFile() != '': iaa.loadExcludedTypes(self.config.getExcludedTypesFile()) iaa.addInferredAxioms(inf_types, annotate_inferred, preprocess_inverses) fileoutpath = self.getOutputFilePath() # Set the ontology IRI. ontIRI = self.config.generateDevIRI(fileoutpath) mainont.setOntologyID(ontIRI) # Write the ontology to the output file. logger.info('Writing compiled ontology to ' + fileoutpath + '...') mainont.saveOntology(fileoutpath, self.config.getOutputFormat()) if self.mergeimports and self.prereason: msgtxt = 'Merged and reasoned ' elif self.mergeimports: msgtxt = 'Merged ' else: msgtxt = 'Reasoned ' logger.info((msgtxt + 'ontology build completed in {0} s.\n').format( timer.stop()))
def init_game(_boardname=None): global player, game name = _boardname if _boardname is not None else 'kolkata_6_10' game = Game('Cartes/' + name + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = 20 # frames per second game.mainiteration() game.mask.allow_overlaping_players = True
def init(_boardname=None): global player,game # pathfindingWorld_MultiPlayer4 name = _boardname if _boardname is not None else 'tictactoe' game = Game('Cartes/' + name + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = 2 # frames per second game.mainiteration() game.mask.allow_overlaping_players = True
def init(_boardname=None): global player, game, tailleV, tailleH name = _boardname if _boardname is not None else 'pathfindingWorld3' game = Game('Cartes/' + name + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = 5 # frames per second game.mainiteration() player = game.player tailleV = game.spriteBuilder.rowsize tailleH = game.spriteBuilder.colsize
def psims_example(): ontology = Ontology(filename='psi-ms.obo', verbose=1) ontology.show() print("============================") term = ontology.terms["MS:1002286"] term.show() print("============================") name = 'QIT' print(f"Searching for '{name}'") if name in ontology.names: curies = ontology.names[name] for curie in curies: term = ontology.terms[curie] term.show() print("============================") name = 'bit' result_list = ontology.fuzzy_search(search_string=name) for item in result_list: print(item) print("============================") name = 'bit' result_list = ontology.fuzzy_search(search_string=name, children_of="MS:1000031") for item in result_list: print(item)
def _run(self): """ Runs the inferencing pipeline. """ #self._retrieveAndCheckFilePaths() if self.srcpath != '': sourceont = Ontology(self.srcpath) else: sourceont = Ontology(JavaSystem.in) logger.info('Running reasoner and adding inferred axioms...') inf_types = self.config.getInferenceTypeStrs() annotate_inferred = self.config.getAnnotateInferred() preprocess_inverses = self.config.getPreprocessInverses() iaa = InferredAxiomAdder(sourceont, self.config.getReasonerStr()) if self.config.getExcludedTypesFile() != '': iaa.loadExcludedTypes(self.config.getExcludedTypesFile()) iaa.addInferredAxioms( inf_types, annotate_inferred, preprocess_inverses ) # Write the ontology to the output file or stdout. format_str = self.config.getOutputFormat() if self.outpath != '': logger.info('Writing compiled ontology to ' + self.outpath + '...') sourceont.saveOntology(self.outpath, format_str) else: sourceont.printOntology(format_str)
def tag(self, task): update = Ontology(self.env, 'ns.medium.resource.meta.tag') meta = self.meta.project('ns.medium.resource.meta.tag') knowledge = Ontology(self.env, 'ns.medium.resource.meta.tag', self.knowledge['body']) genealogy = Ontology(self.env, 'ns.service.genealogy', self.knowledge['head']['genealogy']) knowledge.merge_all(genealogy) # Everything that is in meta but doesn't fit knowledge # should be replaced with the value in knowledge for i in meta.keys(): if meta[i] != knowledge[i]: update[i] = knowledge[i] # Everything that is in knowledge but not in meta # should be set to the value in knowledge for i in knowledge.keys(): if i not in meta: update[i] = knowledge[i] modify = [] for k,v in update.iteritems(): prototype = update.namespace.find(k) if prototype and prototype.node['subler']: modify.append(u'{{{}:{}}}'.format(prototype.node['subler'],v)) print unicode(modify).encode('utf-8')
def run_cso_classifier(paper, modules="both", enhancement="first", explanation=False): if modules not in ["syntactic", "semantic", "both"]: raise ValueError( "Error: Field modules must be 'syntactic', 'semantic' or 'both'") if enhancement not in ["first", "all", "no"]: raise ValueError( "Error: Field enhances must be 'first', 'all' or 'no'") if type(explanation) != bool: raise ValueError( "Error: Explanation must be set to either True or False") # Loading ontology and model cso = CSO() model = MODEL() t_paper = Paper(paper, modules) result = Result(explanation) # Passing parameters to the two classes (synt and sema) and actioning classifiers if modules == 'syntactic' or modules == 'both': synt_module = synt(cso, t_paper) result.set_syntactic(synt_module.classify_syntactic()) if explanation: result.dump_temporary_explanation(synt_module.get_explanation()) if modules == 'semantic' or modules == 'both': sema_module = sema(model, cso, t_paper) result.set_semantic(sema_module.classify_semantic()) if explanation: result.dump_temporary_explanation(sema_module.get_explanation()) result.set_enhanced( cso.climb_ontology(getattr(result, "union"), enhancement)) return result.get_dict()
def _run(self): """ Reads the source ontologies and looks for the search terms. """ ef = EntityFinder() for search_ont in self.search_onts: logger.info('Reading source ontology {0}...'.format(search_ont)) ontology = Ontology(search_ont) logger.info('Processing ontology entities...') ef.addOntologyEntities(ontology) if self.tfpath != '': termsin = open(self.tfpath) else: termsin = sys.stdin if self.outpath != '': logger.info('Writing search results to ' + self.outpath + '...') fout = open(self.outpath, 'w') else: fout = sys.stdout writer = csv.DictWriter(fout, fieldnames=[ 'Search term', 'Matching entity', 'Label(s)', 'Annotation', 'Value', 'Match type', 'Definition(s)' ]) writer.writeheader() row = {} for searchterm in termsin: searchterm = searchterm.strip() results = ef.findEntities(searchterm) for result in results: entity = result[0] row['Search term'] = searchterm row['Matching entity'] = str(entity.getIRI()) row['Label(s)'] = ','.join(entity.getLabels()) row['Annotation'] = result[1] row['Value'] = result[2] row['Definition(s)'] = ','.join(entity.getDefinitions()) if result[3] == MATCH_FULL: row['Match type'] = 'Full' else: row['Match type'] = 'Partial' writer.writerow(row)
def init(_boardname=None): global player, game, nbreCol, nbreLig # pathfindingWorld_MultiPlayer4 name = _boardname if _boardname is not None else 'pathfindingWorld_MultiPlayer5' game = Game('Cartes/' + name + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = 5 # frames per second game.mainiteration() game.mask.allow_overlaping_players = True nbreCol = game.spriteBuilder.colsize - 1 nbreLig = game.spriteBuilder.rowsize - 1 player = game.player
def __init__(self, base_ont_path): # Load the base ontology. self.ontology = Ontology(base_ont_path) # Get a PrefixDocumentFormat/PrefixManager instance so that we can # generate prefix IRIs for label expansions in text entity definitions. owlont = self.ontology.getOWLOntology() ontman = self.ontology.getOntologyManager() self.prefix_df = ontman.getOntologyFormat(owlont).asPrefixOWLOntologyFormat() # A list (used as a stack) for caching information in _TableRow objects # and their associated ontology entity objects. Each list entry is # stored as a tuple, (ontology entity instance, _TableRow instance). self.entity_trows = [] # Create a delimited string parser for parsing multiple values out of # input fields. self.dsparser = DelimStrParser(delimchars=';', quotechars='"') # Create a delimited string parser for parsing the components of # strings with whitespace-separated components, such as individual # property assertions (facts). self.ws_dsparser = DelimStrParser(delimchars=' \t', quotechars='"\'')
def checkOntology(domain): Settings.load_root(root) Settings.load_config(None) Settings.config.add_section("GENERAL") Settings.config.set("GENERAL", 'domains', domain) Ontology.init_global_ontology() gOnt = Ontology.global_ontology for dstring in gOnt.possible_domains: informable = gOnt.get_informable_slots(dstring) for slot in informable: valuesJson = gOnt.get_informable_slot_values(dstring, slot) results = gOnt.ontologyManagers[dstring].db.customQuery( 'SELECT DISTINCT {} FROM {} ORDER BY {} ASC'.format( slot, dstring, slot)) valuesDB = [entry[slot] for entry in results] # valuesDB = map(lambda a : a.lower(),valuesDB) valuesJson.append("not available") difference = list(set(valuesDB) - set(valuesJson)) if len(difference): print dstring + " " + slot + " " + str(difference)
def _run(self): """ Checks for entailment errors in the main ontology. """ mainont = Ontology(self.obt.getOutputFilePath()) timer = BasicTimer() logger.info('Checking for entailment errors...') timer.start() entcheck_res = mainont.checkEntailmentErrors( self.config.getReasonerStr()) logger.info('Logical error check completed in {0} s'.format( timer.stop())) if not (entcheck_res['is_consistent']): logger.info( '\nERROR: The ontology is inconsistent (that is, it has no ' 'models). This is often caused by the presence of an ' 'individual (that is, a class instance) that is explicitly or ' 'implicitly a member of two disjoint classes. It might also ' 'indicate an underlying modeling error. Regardless, it is a ' 'serious problem because an inconsistent ontology cannot be ' 'used for logical inference.\n') else: class_list = entcheck_res['unsatisfiable_classes'] if len(class_list) > 0: iri_strs = [ent.getIRI().toString() for ent in class_list] classes_str = '<' + '>\n<'.join(iri_strs) + '>' logger.info( '\nERROR: The ontology is consistent but incoherent ' 'because it contains one or more unsatisfiable classes. ' 'This usually indicates a modeling error. The following ' 'classes are unsatisfiable:\n' + classes_str + '\n') else: logger.info('\nThe ontology is consistent and coherent. No ' 'entailment problems were found.\n')
def produce(self, override=None): # copy the location ontology p = Ontology.clone(self.location) # allow the location to recalculate those concepts del p['volume path'] del p['file name'] del p['directory'] # explicitly set the volume and host from the task p['host'] = self.env.host p['volume'] = self.ontology['volume'] # for copy and move we try to set a profile from the source if self.ontology['action'] in set(('copy', 'move', 'pack')): if self.resource.meta['profile']: p['profile'] = self.resource.meta['profile'] # for transcode we try to set the profile from the transform elif self.ontology['action'] == 'transcode': for pivot in self.transform.pivot.values(): if 'profile' in pivot.location: p['profile'] = pivot.location['profile'] # whatever happened, if a profile has been explicitly provided by the task # it will override anything we set implicitly if self.ontology['profile']: p['profile'] = self.ontology['profile'] # if an override was given set some concepts from it if override: for i in set(( 'kind', 'language', 'stream order', 'resource path digest', 'routing type' )): if i in override: p[i] = override[i] # try to produce a product product = self.resource.asset.locate_resource(p) if product: self.product.append(product) else: self.log.error(u'Could not determine destination path from:\n%s', self.env.encode_json(p)) return product
def __init__(self, boardNumber=1, boardName=None, fps=5, iterations=100): """ boardNumber : identifiant de la carte de jeu à utiliser. fps : nombre de cadres par seconde. iterations : nombre maximal d'itérations. """ global game if boardName is None: game = Game( 'Cartes/pathfindingWorld_MultiPlayer' + str(boardNumber) + '.json', SpriteBuilder) else: game = Game('Cartes/' + str(boardName) + '.json', SpriteBuilder) game.O = Ontology(True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') game.populate_sprite_names(game.O) game.fps = fps # frames per second game.mainiteration() game.mask.allow_overlaping_players = False self.iterations = iterations
def parse_tree(tree_filename): """Build tree given json file. Args: tree_filename: A string, path of json file describing tree from leaf to root Returns: tree_leaf2root: leaf to root dict sumrule: sumrule dict. """ with open(tree_filename, 'rb') as fp: tree_str = json.loads(fp.read()) tree_leaf2root = {} for k, v in tree_str.items(): if v is not None: tree_leaf2root[int(k)] = int(v) else: tree_leaf2root[int(k)] = None tree = Ontology(tree_leaf2root) sumrule = tree.sumrules return tree_leaf2root, sumrule
def __init__(self, _boardname=None, swap=False, affiche=True): self.game = Game() name = _boardname if _boardname is not None else 'at2' self.game = Game('Cartes/' + name + '.json', SpriteBuilder) self.game.O = Ontology( True, 'SpriteSheet-32x32/tiny_spritesheet_ontology.csv') self.game.populate_sprite_names(self.game.O) self.game.fps = 2 # frames per second self.affiche = affiche if affiche: self.game.mainiteration() self.game.mask.allow_overlaping_players = True # player = game.player # on localise tous les états initiaux (loc du joueur) self.initStates = [o.get_rowcol() for o in self.game.layers['joueur']] print("Init states:", self.initStates) # on localise tous les objets ramassables self.goalStates = [ o.get_rowcol() for o in self.game.layers['ramassable'] ] print("Goal states:", self.goalStates) # on localise tous les murs self.wallStates = [ w.get_rowcol() for w in self.game.layers['obstacle'] ] # print ("Wall states:", self.wallStates) self.nbIteration = 0 if swap: self.goalStates[0], self.goalStates[1] = self.goalStates[ 1], self.goalStates[0] self.players = [o for o in self.game.layers['joueur']]
def _run(self): """ Runs the build process and produces a compiled OWL ontology file. """ # Get the imports modules IRIs from the imports build target. importinfos = self.ibt.getImportsInfo() self._retrieveAndCheckFilePaths() baseont = Ontology(self.base_ont_path) # Add an import declaration for each import module. for importinfo in importinfos: baseont.addImport(importinfo.iristr, True) # Write the base ontology to the output file. fileoutpath = self.getOutputFilePath() logger.info('Writing updated base ontology to ' + fileoutpath + '...') baseont.saveOntology(fileoutpath)
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/2004/02/skos/core#'))
def all_url_test(): l = classgenerator.Library() l2 = classgenerator.Library() l2.base_path = ["gentest","lib","ontologies"] #print ("test of getting global data") g = test_global_data_files.get_global_data() #print (g) predicates = Counter() subjects = Counter() predicate_types = Counter() predicate_types2 = Counter() objects = Counter() rebind(g) for x in g: p = x[1] s = x[0] o = x[2] predicates[p] += 1 subjects[s] += 1 objects[o] += 1 print "predicates" seen = {} libs = {} for (p,v) in predicates.most_common(4230): if 'openlinksw.com' in p: continue if 'cc.rww.io' in p : continue p2 = g.namespace_manager.qname(p) (ns,term) = p2.split(':') m = g.namespace_manager.store.namespace(ns) # skip if str(m) =='http://www.w3.org/1999/xhtml/vocab#': continue if ns not in seen : #print "NS",ns, m seen[ns]=1 if 'ns' in ns: print "g.namespace_manager.bind(\"{prefix}\",\"{url}\",True) ".format(prefix=ns,url=m) #pass path = l.get_module(ns,m) #print ns, m, path if path: importl = l.get_import_path(path) prefix = l.get_import_path(ns) #l.createpath(path) #l.create_module(path,prefix,url=m) #print "import {module} as {prefix}".format(module=importl,prefix=ns) replace= { 'http://purl.org/dc/dcam/' : 'https://raw.githubusercontent.com/dcmi/vocabtool/master/build/dcam.rdf' } if str(m) in replace : o = replace[str(m)] #print "replacing " ,m,"with", o m = o _format = 'guess' turtles = [ 'http://www.w3.org/ns/ldp#', 'http://usefulinc.com/ns/doap#', ] if str(m) in turtles : _format = 'turtle' xmls = [ 'http://xmlns.com/foaf/0.1/', 'http://www.w3.org/ns/auth/cert#', 'http://www.w3.org/ns/auth/acl#', 'http://www.w3.org/2000/10/swap/pim/doc#', 'http://www.w3.org/2003/06/sw-vocab-status/ns#', ] if str(m) in xmls : _format = 'xml' o = Ontology(url=m,prefix=prefix,_format=_format) o.set_path(path) #print "prefix", prefix, m libs[prefix]=o ## now revisit the graph and link it #pprint.pprint(libs) for p in libs: o = libs[p] prefix = o.prefix #print "Lib", p, o.path og = o.fetch(g.namespace_manager) rebind(og) od = o.extract_graph(og,l, libs) ours = od[0] others = od[2] prefixs = od[2] code = [] importcode = [] # create members used_prefixes= {} for x in ours : if 'http' in x : pass else: types=[] # lets try and create a class attrs = ours[x] for y in attrs: p = y[0] s = y[1] p1 = resolve(p) s1 = resolve(s) if p1 == 'rdf.type' : if s1 == 'owl.Restriction' : pass else: types.append(s1) ## append to used types #print "check prefix for import",s,s1 used_prefixes[s[0]] =1 #print "\t","pred",p1,s1 if len(types) > 0: caml= convert2(x) short= convert(x) if caml.startswith('Ub'): pass else: classcode = ast.parse("class {_class}({base}):\n term=\"{name}\"\n".format( _class=caml, name=x, base=",".join(types))) used_prefixes[prefix]=1 alias_code = ast.parse("{alias} = {_class}()\n".format( prefix=prefix, alias=short, _class=caml)) code.append(classcode) code.append(alias_code) ##### create prefixes for x in prefixs: m = prefixs[x] if x not in used_prefixes: continue # remove unused prefixes if x == o.prefix : continue import_module = Module(body=[ImportFrom( module=m.module_name(), names=[alias( name='ontology', asname=x)], level=0)]) #code = "from {module} import ontology as {alias}".format(module=m.module_name(), alias=x) # x = Import(names=[alias( # name=m.module_name(), # asname=None)]), #print(astunparse.dump(ast.parse(code))) importcode.append(import_module) ### if True: npath= "gentest/" + o.path #path = l.get_module(ns,m) #print ns, m, path importl = l.get_import_path(npath) #prefix = l.get_import_path(ns) l.createpath(npath) print "npath",npath #print code l.create_module(npath,o.prefix,url=o.base,members=code,imports=importcode)
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://purl.org/dc/dcam/'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/1999/xhtml/vocab#'))
def parse(self, query): for source in query['sources']: try: document = json.load(source) except ValueError as e: self.log.warning(u'Failed to decode JSON document %s', query['remote url']) self.log.debug(u'Exception raised %s', unicode(e)) else: if 'process' in query['branch']: # Preprocessing the entry. # Method should return a document similar to normal itunes api calls action = getattr(self, query['branch']['process'], None) if action is not None: document = action(document) else: self.log.warning(u'Ignoring unknown process function %s', query['branch']['process']) if not document['resultCount'] > 0: self.log.debug(u'No results found for query %s', query['remote url']) else: if query['branch']['query type'] == 'lookup': for element in document['results']: for product in query['branch']['produce']: if satisfies(element, product['condition']): entry = { 'branch':product['branch'], 'record':{ u'head':{ u'genealogy':Ontology(self.env, 'ns.service.genealogy'), }, u'body':{ u'original':element }, } } # make a caonical node entry['record']['body']['canonical'] = Ontology(self.env, entry['branch']['namespace']) entry['record']['body']['canonical'].decode_all(entry['record']['body']['original'], self.name) # Copy indexed values from the canonical node to the genealogy if 'index' in entry['branch']: for index in entry['branch']['index']: if index in entry['record']['body']['canonical']: entry['record'][u'head'][u'genealogy'][index] = entry['record']['body']['canonical'][index] # Only produce once for each element query['entires'].append(entry) break elif query['branch']['query type'] == 'search': for trigger in query['branch']['resolve']: for element in document['results']: if satisfies(element, trigger['condition']): # Decode concepts from the element and populate the ontology o = Ontology(self.env, trigger['namespace']) o.decode_all(element, self.name) # Make a URI and trigger a resolution ref = o.project('ns.service.genealogy') ref['language'] uri = trigger['format'].format(**ref) self.log.debug(u'Trigger %s resolution', uri) self.resolver.resolve(uri)
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/2002/12/cal/icalSpec#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/ns/adms#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'https://cc.rww.io/vocab#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://purl.org/dc/elements/1.1/'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/2007/05/powder-s#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://purl.org/vocab/changeset/schema#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.rddl.org/purposes#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://rdfs.org/ns/void#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.loc.gov/mads/rdf/v1#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://webns.net/mvcb/'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://creativecommons.org/ns#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/2003/06/sw-vocab-status/ns#'))
def __init__(self): Ontology.__init__(self, Namespace(u'http://www.w3.org/2000/01/rdf-schema#'))
def __init__(self): Ontology.__init__(self, Namespace(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://www.w3.org/2003/01/geo/wgs84_pos#'))
def __init__(self): Ontology.__init__(self, rdflib.term.URIRef(u'http://id.loc.gov/vocabulary/identifiers/'))