transferring rdf to 4store

Question

actually I have a code named rdf.py that generates rdf code ..what I want to do is to directly move that file in 4store.. I have stored the entire code in a variable and want to directly pass that variable to 4store.. is it possible?

the code of rdf.py is below. rdf_code contains the entire rdf code that is generated

import rdflib
from rdflib.events import Dispatcher, Event
from rdflib.graph import ConjunctiveGraph as Graph
from rdflib import plugin
from rdflib.store import Store, NO_STORE, VALID_STORE
from rdflib.namespace import Namespace
from rdflib.term import Literal
from rdflib.term import URIRef
from tempfile import mkdtemp
from gstudio.models import *
from objectapp.models import *
from reversion.models import Version
from optparse import make_option

def get_nodetype(name):
    """
    returns the model the id belongs to.  
    """    
    try:
        """ 
        ALGO:     get object id, go to version model, return for the given id.
        """
        node = NID.objects.get(title=str(name))
        # Retrieving only the relevant tupleset for the versioned objects
        vrs = Version.objects.filter(type=0 , object_id=node.id) 
        # Returned value is a list, so splice it .
        vrs =  vrs[0]

    except Error:
        return "The item was not found."

    return vrs.object._meta.module_name   


def rdf_description(name, notation='xml' ):
    """
    Function takes  title of node, and rdf notation.
    """
    valid_formats = ["xml", "n3", "ntriples", "trix"]
    default_graph_uri = "http://gstudio.gnowledge.org/rdfstore"
    configString = "/var/tmp/rdfstore"

    # Get the Sleepycat plugin.
    store = plugin.get('IOMemory', Store)('rdfstore')

    # Open previously created store, or create it if it doesn't exist yet
    graph = Graph(store="IOMemory",
               identifier = URIRef(default_graph_uri))
    path = mkdtemp()
    rt = graph.open(path, create=False)
    if rt == NO_STORE:
    #There is no underlying Sleepycat infrastructure, create it
        graph.open(path, create=True)
    else:
        assert rt == VALID_STORE, "The underlying store is corrupt"

    # Now we'll add some triples to the graph & commit the changes
   # rdflib = Namespace('http://sbox.gnowledge.org/gstudio/')
    graph.bind("gstudio", "http://gnowledge.org/")
    exclusion_fields = ["id", "rght", "node_ptr_id", "image", "lft", "_state", "_altnames_cache", "_tags_cache", "nid_ptr_id", "_mptt_cached_fields"]
    node_type=get_nodetype(name)
    if (node_type=='gbobject'):
        node=Gbobject.objects.get(title=name)
    elif (node_type=='objecttype'):
        node=Objecttype.objects.get(title=name)
    elif (node_type=='metatype'):
        node=Metatype.objects.get(title=name)
    elif (node_type=='attributetype'):
        node=Attributetype.objects.get(title=name)
    elif (node_type=='relationtype'):
        node=Relationtype.objects.get(title=name)
    elif (node_type=='attribute'):
        node=Attribute.objects.get(title=name)
    elif (node_type=='complement'):
        node=Complement.objects.get(title=name)
    elif (node_type=='union'):
        node=Union.objects.get(title=name)
    elif (node_type=='intersection'):
        node=Intersection.objects.get(title=name)
    elif (node_type=='expression'):
        node=Expression.objects.get(title=name)
    elif (node_type=='processtype'):
        node=Processtype.objects.get(title=name)
    elif (node_type=='systemtype'):
        node=Systemtype.objects.get(title=name)

    node_url=node.get_absolute_url()
    site_add= node.sites.all() 
    a = site_add[0] 
    host_name =a.name
    #host_name=name
    link='http://'
    #Concatenating the above variables will give the url address.

    url_add=link+host_name+node_url
    rdflib = Namespace(url_add)
 # node=Objecttype.objects.get(title=name)

    node_dict=node.__dict__

    subject=str(node_dict['id'])
    for key in node_dict:
        if key not in exclusion_fields:
            predicate=str(key)
            pobject=str(node_dict[predicate])
            graph.add((rdflib[subject], rdflib[predicate], Literal(pobject)))

    rdf_code= graph.serialize(format=notation)

    # print out all the triples in the graph
    for subject, predicate, object in graph:
        print subject, predicate, object

    graph.commit()
    print rdf_code
    graph.close()

can I directly pass the rdf_code to 4store...if yes then how?

Answer 1

The simplest way to do this is to transform that graph into ntriples and send it to http://yourhost:port/data/GRAPH_URI. If you do an HTTP POST then the triples will be appended to the existing graph represented by GRAPH_URI. If you do a HTTP PUT then the current graph will be replaced. If the graph does not exist then it will be created no matter if you POST or PUT.

Taking this function as example:

def assert4s(data,epr,graph,contenttype,flush=False):
    try:
        params = urllib.urlencode({'graph': graph,
                                   'data': data,
                                   'mime-type' : contenttype })
        opener = urllib2.build_opener(urllib2.HTTPHandler)
        request = urllib2.Request(epr,params)
        request.get_method = lambda: ('PUT' if flush else 'POST')
        url = opener.open(request)
        return url.read()
    except Exception, e:
        raise e

If you had the following data:

triples = """<a> <b> <c> .
<d> <e> <f> .
"""

You can do the following call:

assert4s(triples,
         "http://yourhost:port/data/",
         "http://some.org/graph/id",
         "application/x-turtle")

Edit

My previous answer assumed you were using the 4s-httpd server. You can start the SPARQL server in 4store with the following command 4s-httpd -p PORT kb_name. Once you have this running, you can use the following services for:

• http://localhost:port/sparql/ to submit queries
• http://localhost:port/data/ to PUT or POST data files.
• http://localhost:port/update/ to submit SPARQL updates queries.

The 4store SPARQLServer documentation is quite complete.