Python Graph.namespace_manager方法代码示例

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
 def __init__(self):
     from django.conf import settings
     store = plugin.get("SQLAlchemy", Store)(identifier='demo')
     graph = Graph(store, identifier='demo')
     graph.namespace_manager = ns_mgr
     graph.open(Literal("sqlite:///" + settings.BASE_DIR + "demo.db"), create=True)
     self.graph = graph

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def test__dataset__add_proxy_resource_uris_to_graph():
    sample_url = "http://purl.org/dc/elements/1.1/subject"
    ds = DataSet.objects.create(**ds_fields)
    assert ds

    proxy_field = ds.generate_proxyfield_uri("Sjoerd, Siebinga", language="nl")
    assert proxy_field.endswith("/resource/dataset/afrikamuseum/nl/Sjoerd,_Siebinga")
    proxy_field = ds.generate_proxyfield_uri("Sjoerd, Siebinga", language=None)
    assert proxy_field.endswith("/resource/dataset/afrikamuseum/Sjoerd,_Siebinga")

    graph = Graph(identifier="http://acc.dcn.delving.org/resource/aggregation/afrikamuseum/100-1")
    graph.namespace_manager = lod.namespace_manager
    graph.parse(data=test_graph, format='xml')
    assert graph
    assert len(list(graph.objects(predicate=URIRef(sample_url)))) == 3
    assert all(isinstance(obj, Literal) for obj in graph.objects(predicate=URIRef(sample_url)))

    new_graph, converted_literals = ds.update_graph_with_proxy_field(graph, sample_url)
    assert new_graph
    assert converted_literals
    assert all(isinstance(obj, URIRef) for obj in new_graph.objects(predicate=URIRef(sample_url)))

    assert len(converted_literals) == 3
    coined_uri, obj = sorted(converted_literals)[0]
    assert coined_uri.endswith('/resource/dataset/afrikamuseum/beelden')
    assert obj.value == 'beelden'

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def serialize_graph(request, rdfjson, base):

    editgraph = Graph()
    editgraph.parse(data=rdfjson, format="rdf-json")

    namespace_manager = NamespaceManager(Graph())
    for ns in namespaces_dict:
        namespace_manager.bind(ns, Namespace(namespaces_dict[ns]), override=False)

    editgraph.namespace_manager = namespace_manager

    if base:
        """
        RDFLib Module to insert the base during serialization is buggy. Manual insertion needed
        graphxml_string = editgraph.serialize(format="pretty-xml", base=base)
        """
        graphxml_string = editgraph.serialize(format="pretty-xml").decode('utf-8', 'ignore')
        graphxml_string = graphxml_string.replace('rdf:RDF\n', 'rdf:RDF\n  xml:base="' + base +'"\n')
        # print graphxml_string
    else:
        graphxml_string = editgraph.serialize(format="pretty-xml")

    graphxml_to_db = RDF_XML(rdfxml_string = graphxml_string)
    graphxml_to_db.save()
    print graphxml_to_db.id

    return json.dumps({'message':graphxml_to_db.id}) 

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
    def test_owlpyclasses(self):
        # Now we have an empty Graph, we can construct OWL classes in it using the
        # Python classes defined in this module

        a = Class(exNs.Opera, graph=self.graph)

        # Now we can assert rdfs:subClassOf and owl:equivalentClass relationships
        # (in the underlying graph) with other classes using the subClassOf and
        # equivalentClass descriptors which can be set to a list of objects for
        # the corresponding predicates.

        a.subClassOf = [exNs.MusicalWork]

        # We can then access the rdfs:subClassOf relationships

        assert pformat(list(a.subClassOf)) == '[Class: ex:MusicalWork ]', pformat(list(a.subClassOf))

        # This can also be used against already populated graphs:

        owlGraph = Graph().parse(str(OWL_NS))
        nsm = self.graph.namespace_manager
        nsm.bind('owl', OWL_NS, override=False)
        owlGraph.namespace_manager = nsm

        assert pformat(
            list(Class(OWL_NS.Class, graph=owlGraph).subClassOf)) == \
            '[Class: rdfs:Class ]'

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def work_graph():
    """
    Get an in memory graph with the default
    namespace_manager set.
    """
    g = Graph()
    g.namespace_manager = ns_mgr
    return g

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def generate(config, type, data):
	global base
	base = config.BASE_URL
	func_name = 'generate_%s'%type
	if func_name in globals():
		graph = globals()['generate_%s'%type](config, data)
	else:
		doc = BNode()
		uri = base
		graph = Graph('IOMemory', doc)
	graph.namespace_manager = ns
	return graph

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def create_rdf(places):
    g = Graph()
    g.namespace_manager = namespace_manager

    logger.info("Creating RDF data.")
    for place in places:
        try:
            g = create_place_rdf(g, place)
        except KeyError as e:
            logger.error(e)
            logger.error(place)

    return g

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def main():
    namespace_manager = rdf_graph.load_graph_prefixes()

    g = Graph()

    g.namespace_manager = namespace_manager

    prefixes_dict = rdf_graph.load_properties_to_graph(g)

    # print(prefixes_dict['loc']['classes'])

    load_foursquare_venues_to_graph(g, prefixes_dict)

    g.serialize('foursquare.rdf', format='xml')

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def main():
    integrated_restaurants = get_integrated_restaurants()

    namespace_manager = rdf_graph.load_graph_prefixes()

    g = Graph()

    g.namespace_manager = namespace_manager

    prefixes_dict = rdf_graph.load_properties_to_graph(g)

    for restaurant in integrated_restaurants:
        rdf_graph.add_restaurant_triples_to_graph(g, prefixes_dict, restaurant)

    g.serialize('integrated_restaurants.rdf', format='xml')

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def process(input_file, input_format, output_file, output_format, *args,
        new_graph=False, **kwargs):
    """
    Parse the given input file, run `arpa.arpafy`, and serialize the resulting
    graph on disk.

    `input_file` is the name of the rdf file to be parsed.

    `output_file` is the output file name.

    `output_format` is the output file format.

    If `new_graph` is set, use a new empty graph for adding the results.

    All other arguments are passed to `arpa.arpafy`.

    Return the results dict as returned by `arpa.arpafy`.
    """

    g = Graph()
    logger.info('Parsing file {}'.format(input_file))
    g.parse(input_file, format=input_format)
    logger.info('Parsing complete')

    if new_graph:
        output_graph = Graph()
        output_graph.namespace_manager = g.namespace_manager
    else:
        output_graph = g
    kwargs['output_graph'] = output_graph

    logger.info('Begin processing')
    start_time = time.monotonic()

    res = arpafy(g, *args, **kwargs)

    end_time = time.monotonic()

    logger.info("Processing complete, runtime {}".
            format(timedelta(seconds=(end_time - start_time))))

    logger.info('Serializing graph as {}'.format(output_file))
    output_graph.serialize(destination=output_file, format=output_format)
    logger.info('Serialization complete')

    return res

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def project_view(uri):
    g = Graph()
    g.namespace_manager = namespace_manager
    p = graph.resource(uri)
    for triple in graph.triples( (uri, None, None) ):
        g.add(triple)
    for k in [x.identifier for x in p[DOAP.release]]:
        for triple in graph.triples( (k, None, None) ):
            g.add(triple)
    for k in [x.identifier for x in p[DOAP.maintainer]]:
        for triple in graph.triples( (k, None, None) ):
            g.add(triple)
    for k in [x.identifier for x in p[DOAP.developer]]:
        for triple in graph.triples( (k, None, None) ):
            g.add(triple)
    for k in [x.identifier for x in p[DOAP.repository]]:
        for triple in graph.triples( (k, None, None) ):
            g.add(triple)
    return g

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def newgraph(request):
    print request.method

    # Create and bind namespaces
    namespace_manager = NamespaceManager(Graph())
    for ns in namespaces_dict:
        namespace_manager.bind(ns, Namespace(namespaces_dict[ns]))

    # Create a new graph
    graph = Graph()
    graph.namespace_manager = namespace_manager

    triple_list = []
    subject_list = []
    predicate_list = []

    subject_set = {}
    predicate_set = {}
    object_set = {}

    # Determine xml:base
    subject_base_test_set = {triple[0] for triple in triple_list}
    base_set = {subject[:subject.rfind("/")] for subject in subject_base_test_set}
    # If all subjects share the same substring-base, this substring-base is likely to be the xml:base.
    if len(base_set) == 1:
        base = str(list(base_set)[0]) + "/"
    else:
        base = ""

    # Serialize graph
    rdfjson = graph.serialize(None, format="rdf-json")

    # 
    triple_fetcher_classes = get_triple_fetcher_classes()

    response = render_to_response('rdfedit/triples.html',
                                  {'rdfjson': rdfjson, 'triple_list': triple_list, 'subject_set': subject_set,
                                   'predicate_set': predicate_set, 'object_set': object_set,
                                   'namespaces_dict': json.dumps(namespaces_dict), 'base': base,
                                   'triple_fetcher_classes': triple_fetcher_classes},
                                  context_instance=RequestContext(request))

    return response

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def tobj(objname):
    SCHEMA = Namespace('http://schema.org/')
    SPDX = Namespace('http://www.spdx.org/rdf/terms#')
    n = NamespaceManager(Graph())
    n.bind("schema", SCHEMA)
    n.bind("spdx", SPDX)
    c = get_db().cursor()
    c.execute('SELECT * FROM objects WHERE id=?', (objname,))
    obj = c.fetchone()
    g = Graph()
    g.namespace_manager = n
    objuri = URIRef("http://localhost:5000/b/" + obj[0])
    robjuri = URIRef("http://localhost:5000/r/" + obj[0])
    md5node = BNode()
    g.add((md5node, SPDX.checksumValue, Literal(obj[2])))
    g.add((md5node, SPDX.algorithm, URIRef("http://packages.qa.debian.org/#checksumAlgorithm_md5sum")))
    g.add((objuri, SPDX.checksum, md5node))
    g.add((objuri, SCHEMA.fileSize, Literal(obj[1])))
    return Response(g.serialize(format="turtle"), mimetype="text/plain")

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
def load_ontology():
    from FuXi.Horn.HornRules import HornFromN3
    from FuXi.Rete.Util import generateTokenSet
    from FuXi.Rete.RuleStore import SetupRuleStore
    rule_store, rule_graph, network = SetupRuleStore(makeNetwork=True)
    for rule in HornFromN3('rdfs-rules.n3'):
        network.buildNetworkFromClause(rule)
    # for rule in HornFromN3('owl-rules.n3'):
    #     network.buildNetworkFromClause(rule)
    g = Graph(identifier='http://catalyst-fp8.eu/ontology')
    npm = NamespaceManager(g)
    g.namespace_manager = npm
    for name in ('SIOC','OA','CATALYST','IDEA','IBIS','VOTE','VERSION','ASSEMBL','OWL','RDF', 'OWL', 'RDFS', 'XSD'):
        npm.bind(name.lower(), globals()[name])
    for f in ontology_files:
        g.parse(join(dirname(__file__), f), format='turtle')
    network.feedFactsToAdd(generateTokenSet(g))
    for n in network.inferredFacts.triples((None, None, None)):
        g.add(n)
    return g

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import namespace_manager [as 别名]
 def get_skos_from_uri(skos_uri, store=None):
     if store is None:
         store = rdfstore.get_rdfstore()
     response = EDMRecord.get_skos_broader_context_graph(store, skos_uri)
     g = Graph()
     g.namespace_manager = namespace_manager
     for entry in response['results']['bindings']:
         if all([key in ['broader', 'prefLabel', 's'] for key in entry.keys()]):
             triple = (URIRef(entry['broader']['value']), SKOS.prefLabel,
                       Literal(entry['prefLabel']['value'], lang=entry['prefLabel'].get('xml:lang')))
             g.add(triple)
             g.add((URIRef(entry['s']['value']), SKOS.broader, URIRef(entry['broader']['value'])))
         elif all([key in ['s', 'p', 'o'] for key in entry.keys()]):
             subject = URIRef(entry['s']['value'])
             predicate = URIRef(entry['p']['value'])
             obj_value = entry['o']
             if obj_value['type'] == 'literal':
                 obj = Literal(obj_value['value'], lang=obj_value.get('xml:lang'))
             else:
                 obj = URIRef(obj_value['value'])
             g.add((subject, predicate, obj))
     return g