Errata

You might want to note that the samples in the book work with Python v. 2.x, not version 3.x.

Perhaps I mistyped the code tutorial examples, but the sample movies.csv data file downloaded from the book website (http://semprog.com/psw/chapter2/) appears not to contain an intersection of movies directed by Steven Spielberg and starring Harrison Ford. Uploading a corrected sample data file will fix this.

A wrong method name is used on the SimpleGraph object. Typed into the Python console, the error shows up as:

>>> from simplegraph import SimpleGraph
>>> placegraph = SimpleGraph()
>>> placegraph.loadfile("place_triples.txt")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: SimpleGraph instance has no attribute 'loadfile'

Changing the method name to "load" works though, as originally defined on page 24:

>>> placegraph.load("place_triples.txt")

On page 32 the correct method is used again.

On page 30 (Chapter 2) the first code snippet:
>>> placegraph.loadfile("place_triples.txt")

should be

>>> placegraph.load("place_triples.txt")

The line " >>> placegraph.loadfile("places_triples.txt")" generates an error. This is due to the fact there is no procedure in the class called "loadfile".
Should be " >>> placegraph.load("places_triples.txt")"

The method SimpleGraph.query won't generate the output from the examples on page 42. Querying for the contributions results in this output:

[{'?dollars': u'30700.0', '?cont': u'contrib285', '?company': u'BSC'}]

The variable names are still prefixed with "?". This becomes a problem later on page 45 in the first code snippet, because the method InferenceRule.maketriples will try to unpack the binding's dictionary:

def maketriples(self, binding):
return self._maketriples(**binding)

which will result in this error message:

TypeError: _maketriples() got an unexpected keyword argument '?company'


The fix is to change this line in SimpleGraph.query (shown on page 41)

bpos[x] = pos

to

bpos[x[1:]] = pos

This copies the variable name without the prefixed "?".

Note: This error is already fixed in the Python files available for download.

Neither the code in the book on pp. 41-42 for "query" nor the code
on the web site correctly handles the case where a query triple
contains two identical variables each preceded by a question mark,
such as "('?city','inside','?city')".

the code in this Python class is:

> laxquery = [('?company', 'headquarters', 'Los_Angelese_California')]

but it should be:

> laxquery = [('?company', 'headquarters', 'Los_Angeles_California')]

The method EnemyRule._maketriples does not return a list of tuples, as expected by applyinference. This is how it should look like:

def _maketriples(self, person, enemy, rel, partner):
return [(partner, 'enemy', enemy)]

There are some problems with the printed code. When following the book without downloading any of the code the following should be corrected:

def getquery(self):
return [('?place', 'address', '?address')]

should be

def getqueries(self):
return [[('?place', 'address', '?address')]]

Without these changes the geocoder will not match any queries and _maketriples will never be called.

In the code part:
class GeocodeRule(InferenceRule):
def getquery(self):
return [('?place', 'address', '?address')]

the return clause should be return [[('?place', 'address', '?address')]], or no result returned from the original query clause

The two lines which both read:

list(geograph.triples((None, None, None))

are missing a final closing parenthesis and so should be changed to:

list(geograph.triples((None, None, None)))

in the TouristyRule class the function getqueries doesn't return anything. This causes a "None not iterable" error. The final line in this method should be:

return [tr]

Command as written is:

"list(g.triples((None, rdflib.URIRef('foaf:knows'), None)))"

and it returns an empty list. I think this is because there's no xmlns identifying foaf:knows with http://xmlns.com/foaf/0.1/knows.

Changing the command to

"list(g.triples((None, rdflib.URIRef('http://xmlns.com/foaf/0.1/knows'), None)))"

returns a list with 2 triples, the intended result, I think.

Code in the book is:

me = URIRef("http://my.uri.com/goes/here")

This should be:

me = rdflib.URIRef("http://my.uri.com/goes/here")

Command is written

RDF=rdflib.Namespace('http://www.w3.org/TR/rdf-schema/#')

but this points to the rdfs namespace, which has no predicate "type".

The command should have been:

RDF = rdflib.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")

'rdf-type-predicate' is not a valid python variable name - easily fixed by using underscores.

The code example on page 84 shows a graph of movie data represented using the N3 format. The first line of code specifies a prefix "fb", however this prefix is not used in the rest of the code example. On page 73 there is another example of N3 code where prefixes are used for compaction. I believe the example on page 84 should use the prefix for compaction also but this has been overlooked.

The code example on page 84 shows a graph of movie data represented using the N3 format. The first line of code specifies a prefix "fb", however this prefix is not used in the rest of the code example. On page 73 there is another example of N3 code where prefixes are used for compaction. I believe the example on page 84 should use the prefix for compaction also but this has been overlooked.

i could be wrong about the prefix issue i submitted previously -- perhaps i'm confusing prefix with base (which is described in later paragraphs)?

The second prefix (rdf) in this query is unnecessary.

The code creates an instance of urllib2.Request but there is no corresponding import statement at the beginning of the code file.

"British Broadcasting Company (BBC)" should be changed to "British Broadcasting Corporation (BBC)". The BBC is not a commercial organization!

2nd last line of function getBands4Location() printed as

g.parse(StringIO(dbpedia_data),format='xml')

In fact, the data stored in dbpedia_data is in n3 format and the program looks good after changed to

g.parse(StringIO(dbpedia_data),format='n3')

By default the results from Sesame are in binary instead of the expected JSON.
The GET message should contain the header "Accept: application/sparql-results+json". See http://www.openrdf.org/doc/sesame2/system/ch08.html#table-var-binding-formats

Revised pysesame.py code example:

from urllib import urlopen,quote_plus,URLopener

...

def __getsparql__(self,method):
request = URLopener()
request.addheader("Accept", "application/sparql-results+json")
data = request.open(self.baseurl+method).read()

try:
result=loads(data)['results']['bindings']
return result
except:
return [{'error':data}];

There are two problems in postdata causing the convert_jobs.py to fail quietly.
Firstly, there is an extra "/" before "repositories" in the path.
Secondly, the POST message should contain the header "Content-Type: application/rdf+xml". See http://www.openrdf.org/doc/sesame2/system/ch08.html, section 8.5.1.5

import urllib2

...

def postdata(self,data):
host=self.baseurl+'repositories/'+self.repository+'/statements'
request = urllib2.Request(host,data)
request.add_header("Content-Type", "application/rdf+xml")
res=urllib2.urlopen(request)
return res.read()

You suggest to use geocoder.us but that URL is down. I found an alternative one at this IP address 206.220.230.164. Using that IP instead of the URL in the book, you should be able to follow the instructions in the book with no problems.