URL for RDFLib: http://rdflib.net/

With RdfLib, you can do something like this:

   1 import rdflib
   2 from rdflib.TripleStore import TripleStore
   3 
   4 store = TripleStore()
   5 
   6 store.load( "foaf.rdf" )

That loads a particulare FOAF file.

Now, you can print out all the subject-predicate-object triples:

   1 for s,p,o in store:
   2   print s,p,o

...which isn't terribly enlightening, but at least it's something.

Let's suppose you want to find someone with a particular name. And let's further suppose that we don't want to look up the URL that identifies a "name" in FOAF. We'll search for it manually:

   1 for s,p,o in store:
   2   print p

We'll see a bunch of data, like so...:

  ...
http://xmlns.com/foaf/0.1/family_name
http://xmlns.com/foaf/0.1/phone
http://xmlns.com/foaf/0.1/schoolHomepage
http://www.w3.org/2003/01/geo/wgs84_pos#lat
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
http://www.w3.org/2003/01/geo/wgs84_pos#long
http://xmlns.com/foaf/0.1/name
  ...

So, we can pick out the http://xmlns.com/foaf/0.1/name as the one we're looking for:

name="http://xmlns.com/foaf/0.1/name"

...and then find the names:

   1 for s,p,o in store:
   2   if p == name:
   3     print s,o

We get back something like:

_:XzWBAuNC1 Lion Kimbro
_:XzWBAuNC3 Alex Trabeck
_:XzWBAuNC4 Bayle Capp
_:XzWBAuNC6 Mantis Man

(names shielded to protect the guilty)

Now, it's sort of ugly looking at the bNode ("blank node") identifiers for subjects like _:XzWBAuNC1; It would be much easier to see it with a name.

   1 bnode_to_name = {}
   2 for s,p,o in store:
   3   if p == name:
   4     bnode_to_name[s] = o

Then we can look at things a little more nicely:

   1 for s,p,o in store:
   2   if s in bnode_to_name.keys():
   3     print bnode_to_name[s], p, o

You could also make a nice mapping from predicates to human readable names, and use those.

See Also

Discussion

I am surprised that there isn't already an automatic (by RDF, even) way to turn predicates into human readable string names. I imagine that there is, and that I just don't know about it.

I feel I would want to make it so you could make objects and classes out of the RDF graph, and connect them to each other by predicates, which would then be properties of the objects linking out to the other objects.

Alright; Here's something to explore from. :)

-- LionKimbro 2004-06-06 06:31:25

The "rdf" way to turn abitrary properties into human labels would be via a rdfs:label properties of the rdf:Property in the schema. Note that labels can have language tags; note as well that labels don't have to come from the original schema

-- JoshSled 2004-07-31 12:38:34

I believe that the rdfs:label or rdfs:comment things would allow you to stay stuff like: "this is a person node," or something like that.

What I am looking more for is something like, "If you see a Person node, identify that node in a friendly way by just taking the value of the name property, associated with that node."

That is, looking at the blank node, you see it labeled by "Lion Kimbro," rather than: "This is a node describing a Person."

This idea is conceptually closest, I think, to ESW:GraphStyleSheets.

But rather than applying to a whole graph, it is describing how do draw a single node in a graph (in this case,) and- of course- it's textual rather than graphic.

-- LionKimbro 2004-08-01 06:00:23

RdfLib (last edited 2008-11-15 13:59:47 by localhost)

Unable to edit the page? See the FrontPage for instructions.