Python Graph.triples_choices方法代码示例

# 需要导入模块: from rdflib.graph import Graph [as 别名]
# 或者: from rdflib.graph.Graph import triples_choices [as 别名]
    def load_mappings(self, filename, graph=None):
        tmp = Graph()
        if graph is None:
            graph = Graph()
        tmp.load(filename, format=self.extFromFilename(filename))

        skosify.infer.skos_symmetric_mappings(tmp)

        for tr in tmp.triples_choices((None, [SKOS.exactMatch, SKOS.closeMatch, SKOS.broadMatch, SKOS.narrowMatch, SKOS.relatedMatch], None)):
            #if tr[0] in all_concepts:
            graph.add(tr)

        return graph

# 需要导入模块: from rdflib.graph import Graph [as 别名]
# 或者: from rdflib.graph.Graph import triples_choices [as 别名]
    owlGraph = Graph()
    for input in args[0:]:
        if options.verbose:
            print("Parsing ", input, " as ", options.format)
        owlGraph.parse(input, format=options.format)

    Individual.factoryGraph = owlGraph

    def topList(node, g):
        for s in g.subjects(RDF.rest, node):
            yield s

    for negativeClass in owlGraph.subjects(predicate=OWL_NS.complementOf):
        containingList = first(owlGraph.subjects(RDF.first, negativeClass))
        prevLink = None
        while containingList:
            prevLink = containingList
            containingList = first(owlGraph.subjects(RDF.rest, containingList))
        for s, p, o in owlGraph.triples_choices((None,
                                                 [OWL_NS.intersectionOf,
                                                  OWL_NS.unionOf],
                                                 prevLink)):
            _class = Class(s)
            # print(_class.__repr__(True,True))
            ComplementExpansion(_class, debug=options.verbose)


# from FuXi.Horn import ComplementExpansion
# from FuXi.Horn import SubSumptionExpansion
# from FuXi.Horn import ComplementExpansionTestSuite

# 需要导入模块: from rdflib.graph import Graph [as 别名]
# 或者: from rdflib.graph.Graph import triples_choices [as 别名]
    def load(self, filename):
        """
        Note: This loader only loads categories and mappings
        """
        graph = Graph()
        graph.load(filename, format=self.extFromFilename(filename))

        logger.info('Read %d triples from %s', len(graph), filename)

        skosify.infer.skos_symmetric_mappings(graph, related=False)

        # Load mappings
        n_mappings = 0
        n_memberships = 0
        for tr in graph.triples_choices((None, [SKOS.exactMatch, SKOS.closeMatch, SKOS.broadMatch, SKOS.narrowMatch, SKOS.relatedMatch], None)):
            source_concept = tr[0]
            res_id = self.vocabulary.id_from_uri(source_concept)
            if res_id is not None:
                shortName = str(tr[1]).split('#')[1]
                try:
                    self.vocabulary.resources[res_id].add('mappings.%s' % shortName, str(tr[2]))
                    n_mappings += 1
                except KeyError:
                    logger.warning('Concept not found: %s', res_id)

        # Load categories
        for tr in graph.triples((None, RDF.type, UOC.Category)):
            cat_lab = graph.preferredLabel(tr[0], lang='nb')[0][1].value
            cat_id = '' + tr[0]

            cat = Concept().set_type('Category')
            cat.set('id', cat_id)
            cat.set('prefLabel.nb', Label(cat_lab))
            self.vocabulary.resources.load([cat])


            for tr2 in graph.triples((tr[0], SKOS.member, None)):
                uri = str(tr2[2])
                res_id = self.vocabulary.id_from_uri(uri)
                if res_id is not None:
                    try:
                        self.vocabulary.resources[res_id].add('memberOf', cat_id)
                        n_memberships += 1
                    except KeyError:
                        logger.warning('Concept not found: %s', res_id)

        # Load number of ccmapper mapping candidates
        for tr in graph.triples((None, LOCAL.ccmapperCandidates, None)):
            source_concept = tr[0]
            res_id = self.vocabulary.id_from_uri(source_concept)
            if res_id is not None:
                shortName = str(tr[1]).split('#')[1]
                try:
                    self.vocabulary.resources[res_id].set('ccmapperCandidates', int(tr[2]))
                except KeyError:
                    logger.warning('Concept not found: %s', res_id)

        # Load ccmapper mapping state
        for tr in graph.triples((None, LOCAL.ccmapperState, None)):
            source_concept = tr[0]
            res_id = self.vocabulary.id_from_uri(source_concept)
            if res_id is not None:
                shortName = str(tr[1]).split('#')[1]
                try:
                    self.vocabulary.resources[res_id].set('ccmapperState', tr[2])
                except KeyError:
                    logger.warning('Concept not found: %s', res_id)

        logger.info('Loaded %d mappings and %d category memberships from %s', n_mappings, n_memberships, filename)