agent>> PREC>> 返回
项目作者： BruJu

项目描述 ：
Property Graph - RDF Experimental Converter: Translate Property Graphs into RDF graphs by bringing extra semantic by using a context
高级语言： JavaScript
项目地址: git://github.com/BruJu/PREC.git
创建时间： 2021-05-18T20:48:46Z
项目社区：https://github.com/BruJu/PREC
开源协议：MIT License
下载


PG->RDF Experimental Converter

PREC is a set of tools to convert any Property Graph into RDF.

Its main differences with other converters are:

  • It intends to convert the PG into RDF graphs that looks like usual RDF graphs,
    by limiting the amount of boilerplate due to the data being from a Property
    Graph.
  • It enables the user to map some of the labels and property names used in the
    PG to an existing vocabulary, by providing a context written in Turtle format.

PREC uses the PREC ontology that is described at https://bruy.at/prec. The PREC
ontology is mostly used to describe how to convert an RDF graph generated by
PREC with its default modelling into a more user-friendly graph.

Quick start from the repository

The repository contains a data folder with some exportation of Neo4j data by
using the APOC plugin. PREC can be quickly experimented by using these provided
example files.

  • git clone https://github.com/BruJu/PREC

  • npm install --save-dev

  • Example 1: A Property Graph with a node about the POTUS

    • npx ts-node prec.ts apoc2rdf data\ex1_potus.json -c data\ex1_prsc.ttl
    • data\ex1_potus.json contains the exportation of a Neo4J Property Graph
      about the POTUS and the USA.
    • data\ex1_prsc.ttl is a context. In this project, we call a
      Context a Turtle File that describes a mapping from the elements of Property
      Graph to an RDF ontology. This context maps labels of the PG into IRIs
      mainly from DBpedia and Schema.org

  • Example 2: The node Ann likes the node Dan

    • npx ts-node prec.ts apoc2rdf data\ex2_annlikesdan1.json -c data\anndan.ttl

Using PREC as a library

It is possible to import PREC to get access to functions to produce RDF graphs
from a Gremlin or a Neo4j connection. The produced output will be an
RDF/JS DatasetCore.

Example 1

In this example, we want to count the number of nodes and edges in
a local instance of a Neo4j property graph. Because simply looking at
Neo4j Desktop or using properly the Neo4j JS API would be too easy, we are going
to use PREC and count the nodes and edges in the PG thanks to the produced RDF
graph.

  1. // Property Graph API
  2. import neo4j from 'neo4j-driver';
  3. // Some useful RDF imports
  4. import { DataFactory } from 'n3';
  5. import namespace from '@rdfjs/namespace';
  6. const rdf = namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#", { factory: DataFactory });
  7. const pgo = namespace("http://ii.uwb.edu.pl/pgo#"                  , { factory: DataFactory });
  8. // PREC
  9. import { cypherToRDF } from 'prec';
  11. // Open the connection
  12. const auth = neo4j.auth.basic('neo4j', 'password');
  13. const driver = neo4j.driver('neo4j://localhost:7687/neo4j', auth);    
  15. // Build an RDF graph
  16. cypherToRDF(driver)
  17. .then(graph => {
  18.   // We can now count
  19.   console.log(graph.match(undefined, rdf.type, pgo.Node).size + " nodes in the PG");
  20.   console.log(graph.match(undefined, rdf.type, pgo.Edge).size + " edges in the PG");
  21. })
  22. .finally(() => driver.close());

Example 2

You can also provide a context in the form of a list of RDF/JS quads to drive the conversion.

  1. // Property Graph API
  2. import neo4j from 'neo4j-driver';
  3. // Some useful RDF imports
  4. import * as N3 from 'n3';
  5. // PREC
  6. import { cypherToRDF } from 'prec';
  8. // Example Cypher query:
  9. // create ( alice :PERSON  { name: 'Alice' } ) -[:KNOWS]-> ( bob :PERSON { name: 'Bobby' } )
  11. // Open the connection
  12. const auth = neo4j.auth.basic('neo4j', 'password');
  13. const driver = neo4j.driver('neo4j://localhost:7687/neo4j', auth);
  15. // Context
  16. const contextText = `
  17. PREFIX prec: <http://bruy.at/prec#>
  18. PREFIX pvar: <http://bruy.at/prec-trans#>
  19. PREFIX foaf: <http://xmlns.com/foaf/0.1/#>
  20. PREFIX : <http://example.org></http:>
  22. _:PersonRule a prec:PRSCNodeRule ;
  23.   prec:label "PERSON" ;
  24.   prec:propertyKey "name" ;
  25.   prec:produces
  26.     << pvar:self a foaf:Person >> ,
  27.     << pvar:self foaf:name "name"^^prec:valueOf >> .
  29. _:CountryRule a prec:PRSCEdgeRule ;
  30.   prec:label "KNOWS" ;
  31.   prec:produces
  32.     << pvar:source foaf:knows pvar:destination >> ,
  33.     << pvar:self :occurrenceOf << pvar:source foaf:knows pvar:destination >> >> .
  34. `
  36. const contextQuads = new N3.Parser().parse(contextText);
  38. // Build an RDF graph
  39. cypherToRDF(driver, contextQuads)
  40. .then(graph => {
  41.   // Print the RDF graph
  42.   console.log(new N3.Writer().quadsToString(graph.getQuads()));
  43. })
  44. .finally(() => driver.close());
  46. // Expected output:
  47. // _:node0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/#Person> .
  48. // _:node0 <http://xmlns.com/foaf/0.1/#name> "Alice" .
  49. // _:node0 <http://xmlns.com/foaf/0.1/#knows> _:node1 .
  50. // _:node1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/#Person> .
  51. // _:node1 <http://xmlns.com/foaf/0.1/#name> "Bobby" .
  52. // _:edge0 <http://example.org/occurrenceOf> <<_:node0 <http://xmlns.com/foaf/0.1/#knows> _:node1>> .

Using PREC with CLI

Run npx prec -h to have the full list of the current tools.

PG -> RDF

  • If you want to provide a context, use the --context path/to/your/context
    option.

  • From the Cypher or the Gremlin API

    • npx prec cypher2rdf translates Property Graphs from Neo4J to RDF. This
      tool connects itself to the Neo4J instance to extract the nodes
      and relationships (named edges in the rest of PREC).
    • npx prec gremlin2rdf translates “Tinkerpop enabled”
      property graphs to RDF. It works by connecting to the Gremlin API and making
      requests to extract the graph.

  • From a JSON file:

    • npx prec apoc2rdf and npx prec cypherJson2rdf translates Property
      Graphs to RDF. The input is the result of some operations (documented below)
      that you have to do.

  • From an RDF graph:

    • npx prec applyContext applies a context to an RDF graph previously
      generated by another command that did not have any context applied to.

RDF -> PG

  • npx prec prec2pg allows to coming to Property Graphs from a RDF
    previously generated by PREC without applying any context.
    • Example of usage:
      • First we create an RDF graph with a PREC-0 description
        npx prec apoc2rdf data/ex2_annlikesdan3.json > ignore/anndanRDF0.ttl
      • Then we can print the Cypher query to create this graph
        npx prec prec2pg print-cypher ignore/anndanRDF0.ttl
    • Supported format are: a custom representation of the PG, printing the
      cypher query on the console, populating a Cypher compatible database and
      populating a Tinkerpop compatible database.
    • If you used a PRSC well-behaved context to produce the RDF graph, PREC is
      able to un-apply the PRSC context
      • To pass the context, as usual, you just need to use the -c context.ttl
        option.
      • You can hijack this feature to convert some RDF graphs to a PG

Converting your own Property Graph to RDF

The easiest way to transform a Property Graph is by providing a Cypher or a
Gremlin connection, and optionally a context to get a nicer output.

If you do not provide any context, the produced RDF graph will be the “intermediate representation of the PG = PREC-0 graph”. If you have a PREC-0 graph, you can provide it to PREC later with a context to apply the context to the extracted PG.

From Neo4j

By letting PREC connect to the Neo4j database

You can also extract directly the graph from your Neo4J database.

  • npx prec cypher-to-rdf username password (uri-to-your-neo4j-instance) (-c=contextfile.ttl)

Default username should be neo4j and password is the one you entered when
creating the database. Default uri is the local instance with the default Neo4j
parameters.

With the result of a Cypher query

Run a Cypher query like this one:

  • match (src)-[edge]->(dest) return src,edge,dest LIMIT 5
  • The return instruction must return nodes and edges.
    • you can’t write src.myProperty
  • Get the result in JSON format (in Neo4J Browser : choose Export JSON after running the query)
  • Use the cypherJson2rdf sub-command, for example if your output file is data\movies_cypher_all.json
    • npx prec cypherJson2rdf data\movies_cypher_all.json

From a Json Representation of the Property Graph using APOC

You can also use the APOC plugin to extract the content of your Property Graph.

To export a Neo4J property graph from your database, you need to activate APOC file export:

  • Go in your database configuration (click the … right to the database name -> Manage)
  • Plugins -> Install APOC
  • Settings -> add set apoc.export.file.enabled=true -> Apply

To export the graph structure, use this Cypher instruction:
CALL apoc.export.json.all("propertygraph.json",{useTypes:true})

  • npx prec apoc2rdf /path/to/your/propertygraph.json will output the
    Strucural description of the PG in RDF from the
    Json Representation of the Property Graph.

From TinkerPop

npx prec gremlin2rdf (URI to connect to) [-c Context]

The default URI is the URI of a local TinkerPop Server.

License

PREC is licensed under the MIT License by Julian Bruyat / INSA Lyon

The repository includes code from other authors, also licensed under the MIT
License. See test/dataset/DatasetCore.test.js.