Lab: RDFS

2021-03-02T13:58:53Z

Sas020:

=Lab 5: RDFS Programming with rdflib and owlrl=

==Topics==
Basic RDFS graph programming in RDFlib.
Entailments and axioms with owlrl.

==Classes/Methods/Vocabularies==
owlrl.RDFSClosure (RDFS_Semantics, closure, flush_stored_triples)

'''Vocabularies: '''

RDF.type

RDFS.subClassOf, RDFS.subPropertyOf, RDFS.domain, RDFS.range, RDFS.label, RDFS.comment,

==Tasks==
First, pip install owlrl.
The RDFS Vocabulary can be imported from rdflib.namespace, just like FOAF or RDF.

'''Consider the following Scenario:'''
"University of California and University of Valencia are both Universities.
All universities are higher education institutions (HEIs). Only persons can have an expertise, and what they have expertise in is always a subject. Only persons can graduate from a HEI. If you are a student, you are in fact a person as well. That a person is married to someone, means that they know them. Finally, if a person has a name, that name is also the label of that entity."

'''Create RDFS triples corresponding to the text above with RDFlib''' - if you can, try to build on
your example from lab 2!

To create the graph in python, you can just use the g.add syntax as we have done previously, or you can use the following code sample to parse a file into a graph:

<syntaxhighlight>
from rdflib import Graph, Namespace
import owlrl

# Create the graph
g = Graph()

# Parse input data into the graph, format is dependent on the file format. Here turtle (ttl). And location is the path to the local file
g.parse(location="input.ttl", format="turtle")
</syntaxhighlight>

Using these three lines we can add automatically the inferred triples (like ex:University rdf:type ex:Higher_Education_Institute) :
<syntaxhighlight>
rdfs = owlrl.RDFSClosure.RDFS_Semantics(g, False, False, False)
rdfs.closure()
rdfs.flush_stored_triples()
</syntaxhighlight>

After you have done this, try to add the following scenario to you graph as well:
"Having a degree from a HEI means that you have also graduated from that HEI. That a city is a capital of a country means that this city is located in that country. That someone was involved in a meeting, means that they have met the other participants. If someone partook in a meeting somewhere, means that they have visited that place"
To do this, you will have to swap out the line
<syntaxhighlight>
rdfs = owlrl.RDFSClosure.RDFS_Semantics(g, False, False, False)
</syntaxhighlight>
with
<syntaxhighlight>
rdfs = owlrl.OWLRL.OWLRL_Semantics(g, False, False, False)
</syntaxhighlight>
As some of these triples require more advanced reasoning.

Check that simple inference works - make sure that your graph contains triples like these, even if
you have not asserted them explicitly:
* that University of California and Valencia are HEIs
* that Cade, Emma, and Mary are all persons
* that Cade and Emma have both graduated from some HEI
* that Cade knows Mary

One way to check if the triples are there:
<syntaxhighlight>
universities = g.query("""
PREFIX ex: <http://example.org/>
ASK {
ex:University_of_California rdf:type ex:Higher_Education_Institution.
}
""")
print(bool(universities))
</syntaxhighlight>

Rewrite some of your existing code to use rdfs:label in a triple and add an rdfs:comment to the same resource.

==If you have more time...==
Create a new RDFS graph that wraps an empty graph. This graph contains only RDFS axioms. Write it out in Turtle and check that you understand the meaning and purpose of each axiom.

Create an RDF (not RDFS) graph that contains all the triples in your first graph (the one with all the people and universities). Subtract all the triples in the axiom graph from the people/university graph. Write it out to see that you are left with only the asserted and entailed triples and that none of the axioms remain.



==Useful Readings==
*[https://wiki.uib.no/info216/index.php/File:S05-RDFS-11.pdf Lecture Notes]
*[https://wiki.uib.no/info216/index.php/Python_Examples Example page]

2021-02-05T11:49:51Z

Sas020: Minor: Convert schema and dbp namespace-strings to Namespace objects (lecture2 code).

This page will be updated with Python examples related to the lectures and labs. We will add more examples after each lab has ended. The first examples will use Python's RDFlib. We will introduce other relevant libraries later.

==Lecture 1: Python, RDFlib, and PyCharm==

===Printing the triples of the Graph in a readable way===
<syntaxhighlight>
# The turtle format has the purpose of being more readable for humans.
print(g.serialize(format="turtle").decode())
</syntaxhighlight>

===Coding Tasks Lab 1===
<syntaxhighlight>
from rdflib import Graph, Namespace, URIRef, BNode, Literal
from rdflib.namespace import RDF, FOAF, XSD

g = Graph()
ex = Namespace("http://example.org/")

g.add((ex.Cade, ex.married, ex.Mary))
g.add((ex.France, ex.capital, ex.Paris))
g.add((ex.Cade, ex.age, Literal("27", datatype=XSD.integer)))
g.add((ex.Mary, ex.age, Literal("26", datatype=XSD.integer)))
g.add((ex.Mary, ex.interest, ex.Hiking))
g.add((ex.Mary, ex.interest, ex.Chocolate))
g.add((ex.Mary, ex.interest, ex.Biology))
g.add((ex.Mary, RDF.type, ex.Student))
g.add((ex.Paris, RDF.type, ex.City))
g.add((ex.Paris, ex.locatedIn, ex.France))
g.add((ex.Cade, ex.characteristic, ex.Kind))
g.add((ex.Mary, ex.characteristic, ex.Kind))
g.add((ex.Mary, RDF.type, FOAF.Person))
g.add((ex.Cade, RDF.type, FOAF.Person))

</syntaxhighlight>

==Lecture 2: RDF programming==

===Different ways to create an address===

<syntaxhighlight>

from rdflib import Graph, Namespace, URIRef, BNode, Literal
from rdflib.namespace import RDF, FOAF, XSD

g = Graph()
ex = Namespace("http://example.org/")

# How to represent the address of Cade Tracey. From probably the worst solution to the best.

# Solution 1 -
# Make the entire address into one Literal. However, Generally we want to separate each part of an address into their own triples. This is useful for instance if we want to find only the streets where people live.

g.add((ex.Cade_Tracey, ex.livesIn, Literal("1516_Henry_Street, Berkeley, California 94709, USA")))

# Solution 2 -
# Seperate the different pieces information into their own triples

g.add((ex.Cade_tracey, ex.street, Literal("1516_Henry_Street")))
g.add((ex.Cade_tracey, ex.city, Literal("Berkeley")))
g.add((ex.Cade_tracey, ex.state, Literal("California")))
g.add((ex.Cade_tracey, ex.zipcode, Literal("94709")))
g.add((ex.Cade_tracey, ex.country, Literal("USA")))

# Solution 3 - Some parts of the addresses can make more sense to be resources than Literals.
# Larger concepts like a city or state are typically represented as resources rather than Literals, but this is not necesarilly a requirement in the case that you don't intend to say more about them.

g.add((ex.Cade_tracey, ex.street, Literal("1516_Henry_Street")))
g.add((ex.Cade_tracey, ex.city, ex.Berkeley))
g.add((ex.Cade_tracey, ex.state, ex.California))
g.add((ex.Cade_tracey, ex.zipcode, Literal("94709")))
g.add((ex.Cade_tracey, ex.country, ex.USA))

# Solution 4
# Grouping of the information into an Address. We can Represent the address concept with its own URI OR with a Blank Node.
# One advantage of this is that we can easily remove the entire address, instead of removing each individual part of the address.
# Solution 4 or 5 is how I would recommend to make addresses. Here, ex.CadeAddress could also be called something like ex.address1 or so on, if you want to give each address a unique ID.

# Address URI - CadeAdress

g.add((ex.Cade_Tracey, ex.address, ex.CadeAddress))
g.add((ex.CadeAddress, RDF.type, ex.Address))
g.add((ex.CadeAddress, ex.street, Literal("1516 Henry Street")))
g.add((ex.CadeAddress, ex.city, ex.Berkeley))
g.add((ex.CadeAddress, ex.state, ex.California))
g.add((ex.CadeAddress, ex.postalCode, Literal("94709")))
g.add((ex.CadeAddress, ex.country, ex.USA))

# OR

# Blank node for Address.
address = BNode()
g.add((ex.Cade_Tracey, ex.address, address))
g.add((address, RDF.type, ex.Address))
g.add((address, ex.street, Literal("1516 Henry Street", datatype=XSD.string)))
g.add((address, ex.city, ex.Berkeley))
g.add((address, ex.state, ex.California))
g.add((address, ex.postalCode, Literal("94709", datatype=XSD.string)))
g.add((address, ex.country, ex.USA))

# Solution 5 using existing vocabularies for address

# (in this case https://schema.org/PostalAddress from schema.org).
# Also using existing ontology for places like California. (like http://dbpedia.org/resource/California from dbpedia.org)

schema = Namespace("https://schema.org/")
dbp = Namespace("https://dpbedia.org/resource/")

g.add((ex.Cade_Tracey, schema.address, ex.CadeAddress))
g.add((ex.CadeAddress, RDF.type, schema.PostalAddress))
g.add((ex.CadeAddress, schema.streetAddress, Literal("1516 Henry Street")))
g.add((ex.CadeAddress, schema.addresCity, dbp.Berkeley))
g.add((ex.CadeAddress, schema.addressRegion, dbp.California))
g.add((ex.CadeAddress, schema.postalCode, Literal("94709")))
g.add((ex.CadeAddress, schema.addressCountry, dbp.United_States))

</syntaxhighlight>

===Typed Literals===
<syntaxhighlight>
from rdflib import Graph, Literal, Namespace
from rdflib.namespace import XSD
g = Graph()
ex = Namespace("http://example.org/")

g.add((ex.Cade, ex.age, Literal(27, datatype=XSD.integer)))
g.add((ex.Cade, ex.gpa, Literal(3.3, datatype=XSD.float)))
g.add((ex.Cade, FOAF.name, Literal("Cade Tracey", datatype=XSD.string)))
g.add((ex.Cade, ex.birthday, Literal("2006-01-01", datatype=XSD.date)))
</syntaxhighlight>

===Writing and reading graphs/files===

<syntaxhighlight>
# Writing the graph to a file on your system. Possible formats = turtle, n3, xml, nt.
g.serialize(destination="triples.txt", format="turtle")

# Parsing a local file
parsed_graph = g.parse(location="triples.txt", format="turtle")

# Parsing a remote endpoint like Dbpedia
dbpedia_graph = g.parse("http://dbpedia.org/resource/Pluto")
</syntaxhighlight>

===Graph Binding===
<syntaxhighlight>
#Graph Binding is useful for at least two reasons:
#(1) We no longer need to specify prefixes with SPARQL queries if they are already binded to the graph.
#(2) When serializing the graph, the serialization will show the correct expected prefix
# instead of default namespace names ns1, ns2 etc.

g = Graph()

ex = Namespace("http://example.org/")
dbp = Namespace("http://dbpedia.org/resource/")
schema = Namespace("https://schema.org/")

g.bind("ex", ex)
g.bind("dbp", dbp)
g.bind("schema", schema)
</syntaxhighlight>

===Collection Example===

<syntaxhighlight>
from rdflib import Graph, Namespace
from rdflib.collection import Collection

# Sometimes we want to add many objects or subjects for the same predicate at once.
# In these cases we can use Collection() to save some time.
# In this case I want to add all countries that Emma has visited at once.

b = BNode()
g.add((ex.Emma, ex.visit, b))
Collection(g, b,
[ex.Portugal, ex.Italy, ex.France, ex.Germany, ex.Denmark, ex.Sweden])

# OR

g.add((ex.Emma, ex.visit, ex.EmmaVisits))
Collection(g, ex.EmmaVisits,
[ex.Portugal, ex.Italy, ex.France, ex.Germany, ex.Denmark, ex.Sweden])

</syntaxhighlight>

==Lecture 3: SPARQL==

See the [[SPARQL Examples]] page!

===Querying a local ("in memory") graph===

Example contents of the file family.ttl:
@prefix rex: <http://example.org/royal#> .
@prefix fam: <http://example.org/family#> .

rex:IngridAlexandra fam:hasParent rex:HaakonMagnus .
rex:SverreMagnus fam:hasParent rex:HaakonMagnus .
rex:HaakonMagnus fam:hasParent rex:Harald .
rex:MarthaLouise fam:hasParent rex:Harald .
rex:HaakonMagnus fam:hasSister rex:MarthaLouise .

import rdflib

g = rdflib.Graph()
g.parse("family.ttl", format='ttl')

qres = g.query("""
PREFIX fam: <http://example.org/family#>
SELECT ?child ?sister WHERE {
?child fam:hasParent ?parent .
?parent fam:hasSister ?sister .
}""")
for row in qres:
print("%s has aunt %s" % row)

With a prepared query, you can write the query once, and then bind some of the variables each time you use it:
import rdflib

g = rdflib.Graph()
g.parse("family.ttl", format='ttl')

q = rdflib.plugins.sparql.prepareQuery(
"""SELECT ?child ?sister WHERE {
?child fam:hasParent ?parent .
?parent fam:hasSister ?sister .
}""",
initNs = { "fam": "http://example.org/family#"})

sm = rdflib.URIRef("http://example.org/royal#SverreMagnus")

for row in g.query(q, initBindings={'child': sm}):
print(row)

===Select all contents of lists (rdfllib.Collection)===
<syntaxhighlight>

# rdflib.Collection has a different interntal structure so it requires a slightly more advance query. Here I am selecting all places that Emma has visited.

PREFIX ex: <http://example.org/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

SELECT ?visit
WHERE {
ex:Emma ex:visit/rdf:rest*/rdf:first ?visit
}
</syntaxhighlight>

==Lecture 4- SPARQL PROGRAMMING==

===Using parameters/variables in rdflib queries===

<syntaxhighlight>
from rdflib import Graph, Namespace, URIRef
from rdflib.plugins.sparql import prepareQuery

g = Graph()
ex = Namespace("http://example.org/")
g.bind("ex", ex)

g.add((ex.Cade, ex.livesIn, ex.France))
g.add((ex.Anne, ex.livesIn, ex.Norway))
g.add((ex.Sofie, ex.livesIn, ex.Sweden))
g.add((ex.Per, ex.livesIn, ex.Norway))
g.add((ex.John, ex.livesIn, ex.USA))

def find_people_from_country(country):
country = URIRef(ex + country)
q = prepareQuery(
"""
PREFIX ex: <http://example.org/>
SELECT ?person WHERE {
?person ex:livesIn ?country.
}
""")

capital_result = g.query(q, initBindings={'country': country})

for row in capital_result:
print(row)

find_people_from_country("Norway")
</syntaxhighlight>

===SELECTING data from Blazegraph via Python===
<syntaxhighlight>

from SPARQLWrapper import SPARQLWrapper, JSON

# This creates a server connection to the same URL that contains the graphic interface for Blazegraph.
# You also need to add "sparql" to end of the URL like below.

sparql = SPARQLWrapper("http://localhost:9999/blazegraph/sparql")

# SELECT all triples in the database.

sparql.setQuery("""
SELECT DISTINCT ?p WHERE {
?s ?p ?o.
}
""")
sparql.setReturnFormat(JSON)
results = sparql.query().convert()

for result in results["results"]["bindings"]:
print(result["p"]["value"])

# SELECT all interests of Cade

sparql.setQuery("""
PREFIX ex: <http://example.org/>
SELECT DISTINCT ?interest WHERE {
ex:Cade ex:interest ?interest.
}
""")
sparql.setReturnFormat(JSON)
results = sparql.query().convert()

for result in results["results"]["bindings"]:
print(result["interest"]["value"])
</syntaxhighlight>

===Updating data from Blazegraph via Python===
<syntaxhighlight>
from SPARQLWrapper import SPARQLWrapper, POST, DIGEST

namespace = "kb"
sparql = SPARQLWrapper("http://localhost:9999/blazegraph/namespace/"+ namespace + "/sparql")

sparql.setMethod(POST)
sparql.setQuery("""
PREFIX ex: <http://example.org/>
INSERT DATA{
ex:Cade ex:interest ex:Mathematics.
}
""")

results = sparql.query()
print(results.response.read())

</syntaxhighlight>
===Retrieving data from Wikidata with SparqlWrapper===
<syntaxhighlight>
from SPARQLWrapper import SPARQLWrapper, JSON

sparql = SPARQLWrapper("https://query.wikidata.org/sparql")
# In the query I want to select all the Vitamins in wikidata.

sparql.setQuery("""
SELECT ?nutrient ?nutrientLabel WHERE
{
?nutrient wdt:P279 wd:Q34956.
SERVICE wikibase:label { bd:serviceParam wikibase:language "[AUTO_LANGUAGE],en". }
}
""")

sparql.setReturnFormat(JSON)
results = sparql.query().convert()

for result in results["results"]["bindings"]:
print(result["nutrient"]["value"], " ", result["nutrientLabel"]["value"])
</syntaxhighlight>

More examples can be found in the example section on the official query service here: https://query.wikidata.org/.

===Download from BlazeGraph===

<syntaxhighlight>
"""
Dumps a database to a local RDF file.
You need to install the SPARQLWrapper package first...
"""

import datetime
from SPARQLWrapper import SPARQLWrapper, RDFXML

# your namespace, the default is 'kb'
ns = 'kb'

# the SPARQL endpoint
endpoint = 'http://info216.i2s.uib.no/bigdata/namespace/' + ns + '/sparql'

# - the endpoint just moved, the old one was:
# endpoint = 'http://i2s.uib.no:8888/bigdata/namespace/' + ns + '/sparql'

# create wrapper
wrapper = SPARQLWrapper(endpoint)

# prepare the SPARQL update
wrapper.setQuery('CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }')
wrapper.setReturnFormat(RDFXML)

# execute the SPARQL update and convert the result to an rdflib.Graph
graph = wrapper.query().convert()

# the destination file, with code to make it timestamped
destfile = 'rdf_dumps/slr-kg4news-' + datetime.datetime.now().strftime('%Y%m%d-%H%M') + '.rdf'

# serialize the result to file
graph.serialize(destination=destfile, format='ttl')

# report and quit
print('Wrote %u triples to file %s .' %
(len(res), destfile))
</syntaxhighlight>

===Query Dbpedia with SparqlWrapper===

<syntaxhighlight>
from SPARQLWrapper import SPARQLWrapper, JSON

sparql = SPARQLWrapper("http://dbpedia.org/sparql")

sparql.setQuery("""
PREFIX dbr: <http://dbpedia.org/resource/>
PREFIX dbo: <http://dbpedia.org/ontology/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?comment
WHERE {
dbr:Barack_Obama rdfs:comment ?comment.
FILTER (langMatches(lang(?comment),"en"))
}
""")

sparql.setReturnFormat(JSON)
results = sparql.query().convert()

for result in results["results"]["bindings"]:
print(result["comment"]["value"])
</syntaxhighlight>

== Lecture 5: RDFS==

===RDFS-plus (OWL) Properties===
<syntaxhighlight>
g.add((ex.married, RDF.type, OWL.SymmetricProperty))
g.add((ex.married, RDF.type, OWL.IrreflexiveProperty))
g.add((ex.livesWith, RDF.type, OWL.ReflexiveProperty))
g.add((ex.livesWith, RDF.type, OWL.SymmetricProperty))
g.add((ex.sibling, RDF.type, OWL.TransitiveProperty))
g.add((ex.sibling, RDF.type, OWL.SymmetricProperty))
g.add((ex.sibling, RDF.type, OWL.IrreflexiveProperty))
g.add((ex.hasFather, RDF.type, OWL.FunctionalProperty))
g.add((ex.hasFather, RDF.type, OWL.AsymmetricProperty))
g.add((ex.hasFather, RDF.type, OWL.IrreflexiveProperty))
g.add((ex.fatherOf, RDF.type, OWL.AsymmetricProperty))
g.add((ex.fatherOf, RDF.type, OWL.IrreflexiveProperty))

# Sometimes there is no definite answer, and it comes down to how we want to model our properties
# e.g is livesWith a transitive property? Usually yes, but we can also want to specify that a child lives with both of her divorced parents.
# which means that: (mother livesWith child % child livesWith father) != mother livesWith father. Which makes it non-transitive.
</syntaxhighlight>

===RDFS inference with RDFLib===
You can use the OWL-RL package to add inference capabilities to RDFLib. Download it [https://github.com/RDFLib/OWL-RL GitHub] and copy the ''owlrl'' subfolder into your project folder next to your Python files.

[https://owl-rl.readthedocs.io/en/latest/owlrl.html OWL-RL documentation.]

Example program to get started:
<syntaxhighlight>
import rdflib.plugins.sparql.update
import owlrl.RDFSClosure

g = rdflib.Graph()

ex = rdflib.Namespace('http://example.org#')
g.bind('', ex)

g.update("""
PREFIX ex: <http://example.org#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
INSERT DATA {
ex:Socrates rdf:type ex:Man .
ex:Man rdfs:subClassOf ex:Mortal .
}""")

# The next three lines add inferred triples to g.
rdfs = owlrl.RDFSClosure.RDFS_Semantics(g, False, False, False)
rdfs.closure()
rdfs.flush_stored_triples()

b = g.query("""
PREFIX ex: <http://example.org#>
ASK {
ex:Socrates rdf:type ex:Mortal .
}
""")
print('Result: ' + bool(b))
</syntaxhighlight>

===Languaged tagged RDFS labels===
<syntaxhighlight>
from rdflib import Graph, Namespace, Literal
from rdflib.namespace import RDFS

g = Graph()
ex = Namespace("http://example.org/")

g.add((ex.France, RDFS.label, Literal("Frankrike", lang="no")))
g.add((ex.France, RDFS.label, Literal("France", lang="en")))
g.add((ex.France, RDFS.label, Literal("Francia", lang="es")))

</syntaxhighlight>

== Lecture 6: RDFS Plus / OWL ==
===RDFS Plus / OWL inference with RDFLib===

You can use the OWL-RL package again as for Lecture 5.

Instead of:
<syntaxhighlight>
# The next three lines add inferred triples to g.
rdfs = owlrl.RDFSClosure.RDFS_Semantics(g, False, False, False)
rdfs.closure()
rdfs.flush_stored_triples()
</syntaxhighlight>
you can write this to get both RDFS and basic RDFS Plus / OWL inference:
<syntaxhighlight>
# The next three lines add inferred triples to g.
owl = owlrl.CombinedClosure.RDFS_OWLRL_Semantics(g, False, False, False)
owl.closure()
owl.flush_stored_triples()
</syntaxhighlight>

Example updates and queries:
<syntaxhighlight>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX ex: <http://example.org#>

INSERT DATA {
ex:Socrates ex:hasWife ex:Xanthippe .
ex:hasHusband owl:inverseOf ex:hasWife .
}
</syntaxhighlight>

<syntaxhighlight>
ASK {
ex:Xanthippe ex:hasHusband ex:Socrates .
}
</syntaxhighlight>

<syntaxhighlight>
ASK {
ex:Socrates ^ex:hasHusband ex:Xanthippe .
}
</syntaxhighlight>

<syntaxhighlight>
INSERT DATA {
ex:hasWife rdfs:subPropertyOf ex:hasSpouse .
ex:hasSpouse rdf:type owl:SymmetricProperty .
}
</syntaxhighlight>

<syntaxhighlight>
ASK {
ex:Socrates ex:hasSpouse ex:Xanthippe .
}
</syntaxhighlight>

<syntaxhighlight>
ASK {
ex:Socrates ^ex:hasSpouse ex:Xanthippe .
}
</syntaxhighlight>

==Semantic Lifting - CSV==

<syntaxhighlight>
from rdflib import Graph, Literal, Namespace, URIRef
from rdflib.namespace import RDF, FOAF, RDFS, OWL
import pandas as pd

g = Graph()
ex = Namespace("http://example.org/")
g.bind("ex", ex)

# Load the CSV data as a pandas Dataframe.
csv_data = pd.read_csv("task1.csv")

# Here I deal with spaces (" ") in the data. I replace them with "_" so that URI's become valid.
csv_data = csv_data.replace(to_replace=" ", value="_", regex=True)

# Here I mark all missing/empty data as "unknown". This makes it easy to delete triples containing this later.
csv_data = csv_data.fillna("unknown")

# Loop through the CSV data, and then make RDF triples.
for index, row in csv_data.iterrows():
# The names of the people act as subjects.
subject = row['Name']
# Create triples: e.g. "Cade_Tracey - age - 27"
g.add((URIRef(ex + subject), URIRef(ex + "age"), Literal(row["Age"])))
g.add((URIRef(ex + subject), URIRef(ex + "married"), URIRef(ex + row["Spouse"])))
g.add((URIRef(ex + subject), URIRef(ex + "country"), URIRef(ex + row["Country"])))

# If We want can add additional RDF/RDFS/OWL information e.g
g.add((URIRef(ex + subject), RDF.type, FOAF.Person))

# I remove triples that I marked as unknown earlier.
g.remove((None, None, URIRef("http://example.org/unknown")))

# Clean printing of the graph.
print(g.serialize(format="turtle").decode())
</syntaxhighlight>

===CSV file for above example===

<syntaxhighlight>
"Name","Age","Spouse","Country"
"Cade Tracey","26","Mary Jackson","US"
"Bob Johnson","21","","Canada"
"Mary Jackson","25","","France"
"Phil Philips","32","Catherine Smith","Japan"
</syntaxhighlight>

==Semantic Lifting - XML==
<syntaxhighlight>
from rdflib import Graph, Literal, Namespace, URIRef
from rdflib.namespace import RDF, XSD, RDFS
import xml.etree.ElementTree as ET

g = Graph()
ex = Namespace("http://example.org/TV/")
prov = Namespace("http://www.w3.org/ns/prov#")
g.bind("ex", ex)
g.bind("prov", prov)

tree = ET.parse("tv_shows.xml")
root = tree.getroot()

for tv_show in root.findall('tv_show'):
show_id = tv_show.attrib["id"]
title = tv_show.find("title").text

g.add((URIRef(ex + show_id), ex.title, Literal(title, datatype=XSD.string)))
g.add((URIRef(ex + show_id), RDF.type, ex.TV_Show))

for actor in tv_show.findall("actor"):
first_name = actor.find("firstname").text
last_name = actor.find("lastname").text
full_name = first_name + "_" + last_name

g.add((URIRef(ex + show_id), ex.stars, URIRef(ex + full_name)))
g.add((URIRef(ex + full_name), ex.starsIn, URIRef(title)))
g.add((URIRef(ex + full_name), RDF.type, ex.Actor))

print(g.serialize(format="turtle").decode())
</syntaxhighlight>

===XML Data for above example===
<syntaxhighlight>
<data>
<tv_show id="1050">
<title>The_Sopranos</title>
<actor>
<firstname>James</firstname>
<lastname>Gandolfini</lastname>
</actor>
</tv_show>
<tv_show id="1066">
<title>Seinfeld</title>
<actor>
<firstname>Jerry</firstname>
<lastname>Seinfeld</lastname>
</actor>
<actor>
<firstname>Julia</firstname>
<lastname>Louis-dreyfus</lastname>
</actor>
<actor>
<firstname>Jason</firstname>
<lastname>Alexander</lastname>
</actor>
</tv_show>
</data>
</syntaxhighlight>

==Semantic Lifting - HTML==
<syntaxhighlight>
from bs4 import BeautifulSoup as bs, NavigableString
from rdflib import Graph, URIRef, Namespace
from rdflib.namespace import RDF

g = Graph()
ex = Namespace("http://example.org/")
g.bind("ex", ex)

html = open("tv_shows.html").read()
html = bs(html, features="html.parser")

shows = html.find_all('li', attrs={'class': 'show'})
for show in shows:
title = show.find("h3").text
actors = show.find('ul', attrs={'class': 'actor_list'})
for actor in actors:
if isinstance(actor, NavigableString):
continue
else:
actor = actor.text.replace(" ", "_")
g.add((URIRef(ex + title), ex.stars, URIRef(ex + actor)))
g.add((URIRef(ex + actor), RDF.type, ex.Actor))

g.add((URIRef(ex + title), RDF.type, ex.TV_Show))

print(g.serialize(format="turtle").decode())
</syntaxhighlight>

===HTML code for the example above===
<syntaxhighlight>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<div class="tv_shows">
<ul>
<li class="show">
<h3>The_Sopranos</h3>
<div class="irrelevant_data"></div>
<ul class="actor_list">
<li>James Gandolfini</li>
</ul>
</li>
<li class="show">
<h3>Seinfeld</h3>
<div class="irrelevant_data"></div>
<ul class="actor_list">
<li >Jerry Seinfeld</li>
<li>Jason Alexander</li>
<li>Julia Louis-Dreyfus</li>
</ul>
</li>
</ul>
</div>
</body>
</html>
</syntaxhighlight>

==WEB API Calls (In this case JSON)==
<syntaxhighlight>
import requests
import json
import pprint

# Retrieve JSON data from API service URL. Then load it with the json library as a json object.
url = "http://api.geonames.org/postalCodeLookupJSON?postalcode=46020&#country=ES&username=demo"
data = requests.get(url).content.decode("utf-8")
data = json.loads(data)
pprint.pprint(data)
</syntaxhighlight>

==JSON-LD==

<syntaxhighlight>
import rdflib

g = rdflib.Graph()

example = """
{
"@context": {
"name": "http://xmlns.com/foaf/0.1/name",
"homepage": {
"@id": "http://xmlns.com/foaf/0.1/homepage",
"@type": "@id"
}
},
"@id": "http://me.markus-lanthaler.com/",
"name": "Markus Lanthaler",
"homepage": "http://www.markus-lanthaler.com/"
}
"""

# json-ld parsing automatically deals with @contexts
g.parse(data=example, format='json-ld')

# serialisation does expansion by default
for line in g.serialize(format='json-ld').decode().splitlines():
print(line)

# by supplying a context object, serialisation can do compaction
context = {
"foaf": "http://xmlns.com/foaf/0.1/"
}
for line in g.serialize(format='json-ld', context=context).decode().splitlines():
print(line)
</syntaxhighlight>

<div class="credits" style="text-align: right; direction: ltr; margin-left: 1em;">''INFO216, UiB, 2017-2020. All code examples are [https://creativecommons.org/choose/zero/ CC0].'' </div>

==OWL - Complex Classes and Restrictions==
<syntaxhighlight>
import owlrl
from rdflib import Graph, Literal, Namespace, BNode
from rdflib.namespace import RDF, OWL, RDFS
from rdflib.collection import Collection

g = Graph()
ex = Namespace("http://example.org/")
g.bind("ex", ex)
g.bind("owl", OWL)

# a Season is either Autumn, Winter, Spring, Summer
seasons = BNode()
Collection(g, seasons, [ex.Winter, ex.Autumn, ex.Spring, ex.Summer])
g.add((ex.Season, OWL.oneOf, seasons))

# A Parent is a Father or Mother
b = BNode()
Collection(g, b, [ex.Father, ex.Mother])
g.add((ex.Parent, OWL.unionOf, b))

# A Woman is a person who has the "female" gender
br = BNode()
g.add((br, RDF.type, OWL.Restriction))
g.add((br, OWL.onProperty, ex.gender))
g.add((br, OWL.hasValue, ex.Female))
bi = BNode()
Collection(g, bi, [ex.Person, br])
g.add((ex.Woman, OWL.intersectionOf, bi))

# A vegetarian is a Person who only eats vegetarian food
br = BNode()
g.add((br, RDF.type, OWL.Restriction))
g.add((br, OWL.onProperty, ex.eats))
g.add((br, OWL.allValuesFrom, ex.VeganFood))
bi = BNode()
Collection(g, bi, [ex.Person, br])
g.add((ex.Vegetarian, OWL.intersectionOf, bi))

# A vegetarian is a Person who can not eat meat.
br = BNode()
g.add((br, RDF.type, OWL.Restriction))
g.add((br, OWL.onProperty, ex.eats))
g.add((br, OWL.QualifiedCardinality, Literal(0)))
g.add((br, OWL.onClass, ex.Meat))
bi = BNode()
Collection(g, bi, [ex.Person, br])
g.add((ex.Vegetarian, OWL.intersectionOf, bi))

# A Worried Parent is a parent who has at least one sick child
br = BNode()
g.add((br, RDF.type, OWL.Restriction))
g.add((br, OWL.onProperty, ex.hasChild))
g.add((br, OWL.QualifiedMinCardinality, Literal(1)))
g.add((br, OWL.onClass, ex.Sick))
bi = BNode()
Collection(g, bi, [ex.Parent, br])
g.add((ex.WorriedParent, OWL.intersectionOf, bi))

# using the restriction above, If we now write...:
g.add((ex.Bob, RDF.type, ex.Parent))
g.add((ex.Bob, ex.hasChild, ex.John))
g.add((ex.John, RDF.type, ex.Sick))
# ...we can infer with owl reasoning that Bob is a worried Parent even though we didn't specify it ourselves because Bob fullfills the restriction and Parent requirements.

</syntaxhighlight>

Lab: Getting started with VSCode, Python and RDFlib

2021-01-25T15:48:57Z

Sas020: Oppdaterte lenken til forelesningsnotater til å lenke til årets.

=Lab 1: Getting started with Pycharm, Python and RDFlib=

==Topics==
Today we have 2 goals.
1. To setup a programming environment that you will use for the lab excercised and group project (if you don't already have one).
2. To start some basic programming of RDF.

Installation of and introduction to Python, Pycharm, Pip and RDFlib.

'''PyCharm''' is a Python Integrated Development Environment (IDE) that can be used for writing python code.

The '''Pip''' command is used to easily install additional python packages for your coding environment.

'''RDFLib''' is a Python package for working with RDF. With this we can create RDF graphs, parse and serialize RDF, perform SPARQL queries on graphs and more.

==Tasks==

You likely already have '''Python''' installed on your computer (it comes with MAC for instance). To find out, type 'python' in the commandline on windows or type 'python --version' in the terminal on your MAC.
If you don't already have Python, download and install the Python for your operative system [https://www.python.org/downloads/ here.]
We recommend downloading the most recent version.

If you are already using a different Python IDE than Pycharm that you are comfortable with, then you are free to use that program instead.

Otherwise Download and Install the free and open source '''Pycharm Community Edition''' IDE [https://www.jetbrains.com/pycharm/download/ here.]

Start Pycharm and create a new project with a new .py file.

'''RDFlib'''

Using the Pycharm terminal, install RDFlib by simply entering: pip install rdflib

To import rdflib to your .py file, write 'import rdflib' at the top of the file.
Alternatively to import certain modules of rdflib, you can write e.g 'from rdflib import Graph'

'''Coding Tasks'''

When solving the coding tasks you can look at the readings below if needed.
Use the Classes/interfaces and methods listed at the bottom of the page. ()

'''1.''' Write a program that creates an RDF graph containing the triples from the following sentences. Note that one sentence could result in more than one triple.
When solving these particular tasks I would try to avoid using Blank Nodes, and instead use full URI's instead. For URIs you can just use an example URI like "http://example.org/".
This means that if you talk about a person called Cade, the URI could be "http://example.org/Cade". Remember the Namespaces can be used so that you don't have to write the full URI everytime.

* Cade is married to Mary
* The capital of France is Paris
* Cade is 27 years old
* 26 years is the age of Mary
* Marys interests include hiking, chocolate and biology
* Mary is a student
* Paris is a City in France
* Cade and Mary are kind people

==If you have more time...==
If you have more time you can continue extending your graph with some of the stuff from lab 2:
''"Cade has the full name Cade Tracey. He lives in 1516 Henry Street, Berkeley, California 94709, USA. He has a B.Sc. in biology from the University of California, Berkeley from 2011. His interests include birds, ecology, the environment, photography and travelling. He has visited Canada and France."''
Try to use as many different methods as possible to create the triples.

==Documentation and other useful reading==
If needed here is an introduction of how to create projects and python files in Pycharm [https://www.jetbrains.com/help/pycharm/creating-and-running-your-first-python-project.html Pycharm - Tutorial by jetbrains.com].

[https://rdflib.readthedocs.io/en/stable/index.html# RDFLib Documentation]- Todays focus are the following:
* [https://rdflib.readthedocs.io/en/stable/gettingstarted.html Intro to RDFlib]
* [https://rdflib.readthedocs.io/en/stable/intro_to_creating_rdf.html Intro to creating triples]

Additional recommended in depth documentation:
* [https://rdflib.readthedocs.io/en/stable/rdf_terms.html RDF Terms]
* [https://rdflib.readthedocs.io/en/stable/namespaces_and_bindings.html Namespaces and Bindings]

[[:File:S01-KnowledgeGraphs.pdf | Slides from the lecture]]

==Relevant RDFlib interfaces (and methods)==
import [https://rdflib.readthedocs.io/en/stable/py-modindex.html rdflib]:
*Graph (add)
*URIRef
*Literal
*NameSpace
*Bnode
*RDF, FOAF

All RDFlib modules can be found [https://rdflib.readthedocs.io/en/stable/py-modindex.html here]
Browser search (often Ctrl-F) is useful here to find the module that you want.