path: root/patch_my_xo/semanticxo/usr/lib/python2.7/site-packages/semanticxo/graphstore.py

'''
Created on Feb 7, 2012

@author: cgueret
'''
# http://www.w3.org/TR/sparql11-http-rdf-update/
# http://sparql-wrapper.sourceforge.net/resources/doc/
import logging
from rdflib import ConjunctiveGraph, RDF, RDFS, Literal
from rdflib.term import URIRef
from rdflib.namespace import XSD
from SPARQLWrapper import SPARQLWrapper, Wrapper 
import httplib
import uuid
import time
import traceback
import dbus
import binascii
from semanticxo import util
from semanticxo.namespace import OLPC_RESOURCE, OLPC_TERMS, DC_TERMS, \
	OLPC_GRAPHS


class GSResource(object):
	'''
	A Semantic DataStore entry is the description of a single resource
	'''

	def __init__(self, graph, resource_uri):
		'''
		Constructor
		'''
		logging.debug("[GraphStore] Wrap resource %s in graph %s", resource_uri, graph)
		self._resource_uri = resource_uri
		self._graph = graph
		
	def get_resource_uri(self):
		'''
		Return the URI for the resource
		'''
		return self._resource_uri
	
	def add_link_to(self, link_name, target):
		'''
		Create a triple that points to the GSResource target
		'''
		target_uri = target.get_resource_uri()
		self.add(OLPC_TERMS[link_name], target_uri)
	
	def clean(self):
		'''
		Erase all the triples associated to this resource
		'''
		# Preserve the type
		category = self.get_type()
		uid = self.get_uid()
		# remove all
		self._graph.remove((self._resource_uri, None, None))
		# add the type and the uid again
		self.add(RDF.type, category)
		self.add(OLPC_TERMS['uid'], Literal(uid))
	
		
	def get_type(self):
		'''
		Get the type of the resource
		'''
		for (_, _, o) in self._graph.triples((self._resource_uri, RDF.type, None)):
			return o
	
	def get_uid(self):
		'''
		Return the UID
		'''
		for (_, _, o) in self._graph.triples((self._resource_uri, OLPC_TERMS['uid'], None)):
			return o
	
	def get(self, prop):
		'''
		Return the different values associated to a particular property
		'''
		results = []
		p = None
		if type(prop) != URIRef:
			p = OLPC_TERMS[prop]
		else:
			p = prop
		for (_, _, o) in self._graph.triples((self._resource_uri, p, None)):
			results.append(o)
		return results
	
	def get_properties(self):
		'''
		Return the different values associated to a particular property
		'''
		results = []
		for (_, p, _) in self._graph.triples((self._resource_uri, None, None)):
			results.append(p)
		return results
	
	def add(self, p, o):
		'''
		Add a triple to the graph
		'''
		try:
			key = p
			if type(key) != URIRef:
				key = OLPC_TERMS[key]
			value = o
			if type(value) != URIRef and type(value) != Literal:
				if type(value) == dbus.ByteArray:
					hexvalue = binascii.hexlify(value)
					value = Literal(hexvalue, datatype=XSD.hexBinary)
				else:
					value = Literal(value)
			
			self._graph.add((self._resource_uri, key, value))
		except:
			logging.debug('[SDS] Can not store value of type %s for %s', type(value), p)
			traceback.print_exc()
			
	def set(self, key, o):
		'''
		Set a triple, erasing all others using the same predicate
		'''
		if type(key) != URIRef:
			key = OLPC_TERMS[key]
		self._graph.remove((self._resource_uri, key, None))
		self.add(key, o)
		
class GSGraph(object):
	'''
	A Semantic DataStore object is a named graph with an assigned UUID.
	It is a wrapper around a set of triples that contains, at least a triple
	indicating that the named graph is a Semantic DataStore object
	'''

	def __init__(self, graph_uri, payload=None):
		'''
		Constructor
		'''
		# The URI of that graph
		self._graph_uri = graph_uri
		
		if payload == None:
			# No RDF has been given, initialize the graph with default values
			self._graph = ConjunctiveGraph()
			self._graph.add((self._graph_uri, RDF.type, OLPC_TERMS['DataGraph']))
			self._graph.add((self._graph_uri, DC_TERMS['author'], util.device_uri()))
		else:
			# Load the given RDF
			self._graph = payload
			
	def get_graph_uri(self):
		return self._graph_uri
	
	def as_ntriples(self):
		'''
		Return the content of the graph as NTriples
		'''
		# Update last modification time
		self._graph.remove((self._graph_uri, DC_TERMS['modified'], None))
		self._graph.add((self._graph_uri, DC_TERMS['modified'], Literal(int(time.time()))))
		return self._graph.serialize(format='nt')
	
	def as_rdfxml(self):
		'''
		Return the content of the graph as RDF/XML
		'''
		# Update last modification time
		self._graph.remove((self._graph_uri, DC_TERMS['modified'], None))
		self._graph.add((self._graph_uri, DC_TERMS['modified'], Literal(int(time.time()))))
		return self._graph.serialize()
		
	def create_resource(self, uid=None, category=None):
		'''
		Return a new resource entry to be added to an instance of GSGraph
		'''
		if category == None:
			category = 'GenericResource'
		if uid == None:
			uid = str(uuid.uuid4())
		# Create the resource
		resource = GSResource(graph=self._graph, resource_uri=OLPC_RESOURCE[uid])
		resource.add(RDF.type, OLPC_TERMS[category])
		resource.add(OLPC_TERMS['uid'], Literal(uid))
		# Declare it to the graph object
		self._graph.add((self._graph_uri, RDFS.member, resource.get_resource_uri()))
		print "Connect "
		print (self._graph_uri, RDFS.member, resource.get_resource_uri())
		return resource
	
	def get_resource(self, uri):
		'''
		Return a wrapper object for a resource in the graph
		'''
		resource_uri = uri
		if type(resource_uri) != URIRef:
			resource_uri = URIRef(uri)
		return GSResource(graph=self._graph, resource_uri=uri)

	def get_resources_list(self, restrict=None):
		results = []
		restrict_uri = None
		if restrict != None:
			restrict_uri = OLPC_TERMS[restrict]
		for t in self._graph.triples((None, RDF.type, restrict_uri)):
			(s, _, o) = t
			if o != OLPC_TERMS['DataGraph']:
				results.append(s)
		return results

	def find_resources(self, key, value):
		results = []
		if type(key) != URIRef:
			key = OLPC_TERMS[key]
		for t in self._graph.triples((None, key, value)):
			(s, _, o) = t
			results.append(s)
		return results
	
	def add_share(self, contact):
		'''
		Add the unique identifier (IRI) of someone else to share the graph with
		'''
		self._graph.add((self._graph_uri, OLPC_TERMS['shared_with'], contact))

	def remove_share(self, contact):
		'''
		Remove the sharing autorisation with the unique identifier (IRI)
		'''
		self._graph.remove((self._graph_uri, OLPC_TERMS['shared_with'], contact))

	def set(self, key, value):
		'''
		Assign a specific key/value pair to the graph
		'''
		self._graph.remove((self._graph_uri, key, None))
		self._graph.add((self._graph_uri, key, Literal(value)))
		
class GraphStore(object):
	'''
	The Semantic DataStore is an interface to the triple store.		 
	'''

	def __init__(self, hostname=None):
		'''
		Constructor
		@param store_address the address of the triple store
		'''
		if hostname == None:
			hostname = 'localhost:8080'
		self.store_address = hostname
		
	def get_graphs_list(self, restrict=None):
		'''
		Returns a list of the objects stored in this store
		'''
		# ask for all instances of data graphs
		query_string = "SELECT DISTINCT ?graph WHERE { ?graph a <%s>. ?graph <http://purl.org/dc/terms/modified> ?mdate.} ORDER BY ?mdate" % OLPC_TERMS['DataGraph']
		if restrict != None:
			query_string = "SELECT DISTINCT ?graph WHERE { GRAPH ?graph {?e a <%s>. } ?graph <http://purl.org/dc/terms/modified> ?mdate. } ORDER BY ?mdate " % OLPC_TERMS[restrict]
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query_string)
		results = sparql.query().convert()
		liste = [result["graph"]["value"] for result in results["results"]["bindings"]]
		return liste

	def get_resources_list(self, restrict=None):
		'''
		Return a list of URIs for instances of a particular class
		'''
		results = []
		graph_ids = self.get_graphs_list(restrict=restrict)
		for graph_id in graph_ids[::-1]:
			graph = self.get_graph(graph_id)
			resource_ids = graph.get_resources_list(restrict=restrict)
			for resource_id in resource_ids:
				results.append(resource_id)
		return results
	
	def get_resource(self, identifier):
		'''
		Return the indicated resource
		'''
		# First find the graph that contains that resource and for which we are the author
		graphs = []
		query_string = ""
		query_string += "SELECT DISTINCT ?graph WHERE {"
		query_string += "?graph a <%s>." % OLPC_TERMS['DataGraph']
		query_string += "?graph <%s> ?mdate." % DC_TERMS['modified']
		query_string += "?graph <%s> <%s>." % (RDFS.member, identifier)
		# query_string += "?graph <%s> <%s>." % (DC_TERMS['author'], util.device_uri())
		query_string += "}"
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query_string)
		results = sparql.query().convert()
		for result in results["results"]["bindings"]:
			graphs.append(result['graph']['value'])
		if len(graphs) == 0:
			return None
		
		# Load the graph and return the requested resource
		graph = self.get_graph(graphs[0])
		return graph.get_resource(identifier)
		
	def get_graphs_modification_date(self):
		'''
		Return a map associating to each public graph its modification date
		'''
		graphs = {}
		query_string = ""
		query_string += "SELECT DISTINCT ?graph ?date WHERE {"
		query_string += "?graph a <%s> ." % OLPC_TERMS['DataGraph']
		query_string += "?graph <%s> ?date ." % DC_TERMS['modified']
		query_string += "?graph <%s> ?share." % OLPC_TERMS['shared_with']
		query_string += "FILTER ("
		query_string += "?share = <%s>" % util.public_uri()
		query_string += "||"
		query_string += "?share = <%s>" % util.device_uri()
		query_string += ")"
		query_string += "}"
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query_string)
		results = sparql.query().convert()
		for result in results["results"]["bindings"]:
			graphs[result['graph']['value']] = result['date']['value']
		return graphs
		
	def persist_graph(self, gs_graph):
		'''
		Save an object into the store
		'''
		iri = gs_graph.get_graph_uri()
		payload = gs_graph.as_rdfxml()
		headers = { 'Accept' : '*/*', 'Content-Type': 'application/rdf+xml' }
		conn = httplib.HTTPConnection(self.store_address)
		conn.request("PUT", "/data/?graph=%s" % iri, body=payload, headers=headers)
		conn.getresponse()
		conn.close()
		
	def delete_graph(self, ds_object):
		'''
		Delete an object from the store
		'''
		conn = httplib.HTTPConnection(self.store_address)
		conn.request("DELETE", "/data/?graph=%s" % ds_object.get_graph_uri())
		conn.close()
	
	def create_graph(self, name=None):
		'''
		Return a new object for the store
		'''
		uid = str(uuid.uuid4())
		graph_iri = OLPC_GRAPHS[uid]
		graph = GSGraph(graph_iri)
		if name != None:
			graph.set(OLPC_TERMS["name"], name)
		return graph

	def get_graph(self, object_iri):
		'''
		Return an instance of a GSGraph
		'''
		if type(object_iri) != URIRef:
			object_iri = URIRef(object_iri)
		query_string = "CONSTRUCT {?s ?p ?o} WHERE { GRAPH <%s> {?s ?p ?o} }" % object_iri
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.RDF)
		sparql.setQuery(query_string)
		return GSGraph(object_iri, sparql.query().convert())
	
	def get_graph_by_name(self, name):
		'''
		Return an instance of a GSGraph that has the indicated name and has been authored by this device
		'''
		# Look for a matching graph
		query_string = "SELECT DISTINCT ?graph WHERE {"
		query_string += "?graph a <%s>." % OLPC_TERMS['DataGraph']
		query_string += "?graph <%s> <%s>." % (DC_TERMS['author'], util.device_uri())
		query_string += "?graph <%s> \"%s\"." % (OLPC_TERMS['name'], Literal(name))
		query_string += "}"
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query_string)
		results = sparql.query().convert()
		graphs = [result["graph"]["value"] for result in results["results"]["bindings"]]
		if len(graphs) == 0:
			return None
		
		# Return the graph
		return self.get_graph(graphs[0])
	
	def get_graph_by_content(self, uid):
		'''
		Return an object which contains a description about UID
		'''
		# First, try to find a graph
		query_string = """
			SELECT DISTINCT ?graph WHERE { 
			GRAPH ?graph {?s <%s> '%s'}. 
			?graph a <%s>. 
			}
		""" % (OLPC_TERMS['uid'], uid, OLPC_TERMS['DataGraph'])
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query_string)
		results = sparql.query().convert()
		graphs = [result["graph"]["value"] for result in results["results"]["bindings"]]
		if len(graphs) == 0:
			return None
		
		# Return the graph
		return self.get_graph(graphs[0])
		
	def get_metadata(self, uid, properties=None):
		resource_iri = OLPC_RESOURCE[uid]
		metadata = {}
		query = 'SELECT DISTINCT ?p ?o WHERE { <%s> ?p ?o. }' % resource_iri
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query)
		res = sparql.query().convert()
		for result in res['results']['bindings']:
			if result['p']['value'].startswith(OLPC_TERMS):
				key = result['p']['value'].split(OLPC_TERMS)[1]
				if properties == None or key in properties:
					r = None
					if result['o']['type'] == 'literal':
						if 'datatype' in result['o']:
							if result['o']['datatype'] == str(XSD.integer):
								r = int(result['o']['value'])
							elif result['o']['datatype'] == str(XSD.long):
								r = long(result['o']['value'])
							elif result['o']['datatype'] == str(XSD.hexBinary):
								r = dbus.ByteArray(binascii.unhexlify(result['o']['value']))
							else:
								logging.debug('[SDS] Unknown data type %s', result['o']['datatype'])
								traceback.print_exc()
						else:
							r = str(result['o']['value'])
					elif result['o']['type'] == 'uri':
						r = str(result['o']['value'])
					metadata[key] = r
				
		# HACK: This is expected to be always present
		if 'creation_time' not in metadata:
			metadata['creation_time'] = int(time.time())
		
		return metadata
	
	def execute_select(self, query):
		sparql = SPARQLWrapper("http://%s/sparql" % self.store_address)
		sparql.setReturnFormat(Wrapper.JSON)
		sparql.setQuery(query)
		res = sparql.query().convert()
		return res['results']['bindings']
		
_instance = None

def get_instance():
	global _instance
	if _instance is None:
		_instance = GraphStore()
	return _instance

if __name__ == '__main__':
	semantic_ds = GraphStore('localhost')
	# ds_object = semantic_ds.create_object()
	# semantic_ds.persist_object(ds_object)
	# objects = semantic_ds.get_objects_list()
	# for o in objects:
	# 	print semantic_ds.get_object(o).as_ntriples()
	print semantic_ds.get_metadata('5e6a2172-9e23-4732-a0b8-5766026dce7b')