def __init__(self, gc):
     '''
     Constructor
     '''
     self.__globalContext = gc
     plugin.register("sparql", query.Processor, "rdfextras.sparql.processor", "Processor")
     plugin.register("sparql", query.Result, "rdfextras.sparql.query", "SPARQLQueryResult")

def registerplugins():
    """
    Register plugins.

    If setuptools is used to install rdflib-sqlalchemy, all the provided
    plugins are registered through entry_points. This is strongly recommended.

    However, if only distutils is available, then the plugins must be
    registed manually.

    This method will register all of the rdflib-sqlalchemy Store plugins.

    """
    from rdflib.store import Store
    from rdflib import plugin

    try:
        x = plugin.get("SQLAlchemy", Store)
        del x
        return  # plugins already registered
    except:
        pass  # must register plugins

    # Register the plugins ...

    plugin.register(
        "SQLAlchemy",
        Store,
        "rdflib_sqlalchemy.store",
        "SQLAlchemy",
    )

def get_profiles():
	realprofiles=dict()
	realprofileindices=dict()
	annotationpool=[]
	out=open("../results/EvolutionaryProfileSizes.tsv",'w')
	register('text/rdf+n3', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser')
	g = rdflib.Graph()
	result = g.parse('../data/realprofilesold.ttl', format='n3')
	index=0
	for stmt in g:
		profileid=stmt[0]
		annotation=stmt[2]
		if "VTO" in profileid:
			profileid=profileid.replace("http://purl.obolibrary.org/obo/","").replace("#profile","")
			if profileid not in realprofiles:
				realprofiles[profileid]=set()
			realprofiles[profileid].add(annotation)
			annotationpool.append(annotation)

			if profileid not in realprofileindices:
				realprofileindices[profileid]=set()	
			realprofileindices[profileid].add(index)
			index+=1	
	print "Created real profiles"
	for profileid in realprofiles:
		out.write(profileid+"\t"+str(len(realprofiles[profileid]))+"\n")
	return realprofiles,annotationpool,realprofileindices

	def __register_Turtle_serializer(formatstring) :
		"""The default Turtle Serializers of RDFlib is buggy and not very nice as far as the output is concerned. 
		An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package.
		@param formatstring: the string to identify this serializer with.
		"""
		from rdflib.plugin import register
		from rdflib.syntax import serializer, serializers
		register(formatstring, serializers.Serializer, "pyRdfa.serializers.TurtleSerializer", "TurtleSerializer")

	def __register_XML_serializer(formatstring) :
		"""The default XML Serializer of RDFlib is buggy, mainly when handling lists.
		An L{own version<serializers.PrettyXMLSerializer>} is 
		registered in RDFlib and used in the rest of the package.
		@param formatstring: the string to identify this serializer with.
		"""
		from rdflib.plugin import register
		from rdflib.syntax import serializer, serializers
		register(formatstring, serializers.Serializer, "pyRdfa.serializers.PrettyXMLSerializer", "PrettyXMLSerializer")

	def _register_JSON_serializer_3(self) :
		"""JSON LD serializer 
		"""
		if not MyGraph.json_serializer_registered :
			from rdflib.plugin import register
			from rdflib.serializer import Serializer
			register(_json_serializer_name, Serializer,
					 "pyRdfaExtras.serializers.jsonserializer", "JsonSerializer")
			MyGraph.json_serializer_registered = True

def initialize(parameters):
    # Try to add Neo as a backend for RDFLib
    try:
        from rdflib import plugin
        from rdflib.store import Store
        import neo4j._rdf # assert that the RDF subsystem is available
    except: # requirements failed, don't register the hook
        pass
    else: # register the hook
        plugin.register('Neo', Store, 'neo4j._hooks.rdflib', 'NeoRdfStore')

	def _register_XML_serializer_3(self) :
		"""The default XML Serializer of RDFLib 3.X is buggy, mainly when handling lists. An L{own version<serializers.prettyXMLserializer_3>} is
		registered in RDFlib and used in the rest of the package. 
		"""
		if not MyGraph.xml_serializer_registered_3 :
			from rdflib.plugin import register
			from rdflib.serializer import Serializer
			register(_xml_serializer_name, Serializer,
					 "pyRdfa.serializers.prettyXMLserializer_3", "PrettyXMLSerializer")
			MyGraph.xml_serializer_registered_3 = True

	def _register_Turtle_parser_2(self) :
		"""The default Turtle parser of RDFLib 2.X is buggy: some constants, like 'true' or 'false', are not handled.
		An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package.
		This is not used for RDFLib 3.X.
		"""
		if not MyGraph.turtle_parser_registered_2 :
			from rdflib.plugin import register
			from rdflib.syntax 	import parsers
			register(_turtle_parser_name, parsers.Parser, "RDFClosure.parsers.N3Parser","N3Parser")
			MyGraph.turtle_parser_registered_2 = True

	def _register_Turtle_serializer_3(self) :
		"""The default Turtle Serializers of RDFLib 2.X is buggy and not very nice as far as the output is concerned.
		An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package.
		This is not used for RDFLib 3.X.
		"""
		if not MyGraph.turtle_serializer_registered_3 :
			from rdflib.plugin import register
			from rdflib.serializer import Serializer
			register(_turtle_serializer_name, Serializer,
					 "RDFClosure.serializers.TurtleSerializer_3", "TurtleSerializer")
			MyGraph.turtle_serialzier_registered_3 = True

    def buildProvenanceTrail(self):
        self.log.debug("Loading provenance trail")
        plugin.register("sparql", query.Processor, "rdfextras.sparql.processor", "Processor")
        plugin.register("sparql", query.Result, "rdfextras.sparql.query", "SPARQLQueryResult")

        #        self.log.debug(self.g.serialize(format='turtle'))

        expressions_works = self.g.query(
            """SELECT DISTINCT ?w ?e
       WHERE {
          ?w rdf:type frbr:Work .
          ?e frbr:realizationOf ?w .
          ?e provo:wasGeneratedAt ?t .
          ?t time:inXSDDateTime ?dt .
       } ORDER BY ?w, ?dt """,
            initNs=dict(
                frbr=Namespace("http://purl.org/vocab/frbr/core#"),
                provo=Namespace("http://www.w3.org/ns/prov-o/"),
                time=Namespace("http://www.w3.org/2006/time#"),
            ),
        )
        #        self.log.debug(expressions_works.result)

        for row in expressions_works.result:
            (work, expression) = row

            self.trail.setdefault(work, []).append(expression)

            self.log.debug("Work: %s\nExpression: %s" % (work, expression))

        activities = self.g.query(
            """SELECT DISTINCT ?a
       WHERE {
          ?a rdf:type provo:Activity .
          ?a provo:endedAt ?t .
          ?t time:inXSDDateTime ?dt .
       } ORDER BY ?dt """,
            initNs=dict(
                frbr=Namespace("http://purl.org/vocab/frbr/core#"),
                provo=Namespace("http://www.w3.org/ns/prov-o/"),
                time=Namespace("http://www.w3.org/2006/time#"),
            ),
        )
        self.log.debug(activities.result)

        for row in activities.result:

            self.trail.setdefault(self.PROV["Activity"], []).append(row)

            self.log.debug("Activity: %s" % (row))

        self.log.debug(self.trail)
        #        quit()
        return

	def _register_XML_serializer_2(self) :
		"""The default XML Serializer of RDFLib 2.X is buggy, mainly when handling lists.
		An L{own version<serializers.prettyXMLserializer>} is
		registered in RDFlib and used in the rest of the package. This is not used for RDFLib 3.X.
		"""
		if not MyGraph.xml_serializer_registered_2 :
			from rdflib.plugin import register
			from rdflib.syntax import serializer, serializers
			register(_xml_serializer_name, serializers.Serializer,
					 "pyRdfaExtras.serializers.prettyXMLserializer", "PrettyXMLSerializer")
			MyGraph.xml_serializer_registered_2 = True

	def _register_Turtle_serializer_2(self) :
		"""The default Turtle Serializers of RDFLib 2.X is buggy and not very nice as far as the output is concerned.
		An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package.
		This is not used for RDFLib 3.X.
		"""
		if not MyGraph.turtle_serializer_registered_2 :
			from rdflib.plugin import register
			from rdflib.syntax import serializer, serializers
			register(_turtle_serializer_name, serializers.Serializer,
					 "pyRdfaExtras.serializers.turtleserializer", "TurtleSerializer")
			MyGraph.turtle_serialzier_registered_2 = True

def test_jsonld():
    # generate shared canvase json-ld
    tei_file = "../../data/tei/ox/ox-frankenstein_notebook_c1.xml"
    manifest_uri = 'http://example.com/frankenstein.json'
    m = Manifest(tei_file, manifest_uri)
    jsonld = m.jsonld()

    # parse the json-ld as rdf
    register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser')
    g = ConjunctiveGraph()
    g.parse(data=jsonld, format='json-ld')

    # sanity check the graph
    assert g.value(URIRef('http://example.com/frankenstein.json'), RDF.type) == URIRef('http://www.shared-canvas.org/ns/Manifest')

def test_jsonld():
    # generate shared canvase json-ld
    tei_file = "sga/data/tei/ox/ox-frankenstein_notebook_c1.xml"
    manifest_uri = 'http://example.com/frankenstein.json'
    m = Manifest(tei_file, manifest_uri)
    jsonld = m.jsonld()
    open('test.jsonld', 'w').write(json.dumps(jsonld, indent=2))

    # find the manifest
    manifest = None
    for r in jsonld['@graph']:
        if '@type' in r and r['@type'] == 'sc:Manifest':
            manifest = r
    assert manifest

    # check for images
    assert 'images' in manifest

    # check for canvases
    assert 'canvases' in manifest

    # get the sequence
    assert 'sequences' in manifest
    seq = get(jsonld, manifest['sequences'][0])

    # first canvas
    assert 'first' in seq
    canvas = get(jsonld, seq['first'])
    assert canvas['label'] == '1r'

    # check the content annotations
    assert count_type(jsonld, 'sc:ContentAnnotation') == 90
   
    # css should be there
    assert count_type(jsonld, 'cnt:ContentAsText') == 61

    # parse the json-ld as rdf
    register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser')
    g = ConjunctiveGraph()
    jsonld_str = json.dumps(jsonld)
    g.parse(data=jsonld_str, format='json-ld')

    # quick sanity check the graph
    assert g.value(URIRef('http://example.com/frankenstein.json'), RDF.type) == URIRef('http://www.shared-canvas.org/ns/Manifest')
    line_anns = list(g.triples((None, RDF.type, SGA.LineAnnotation)))
    assert len(line_anns) == 638

 def __init__(self, directory, config, level = logging.DEBUG):
     """TabLinker constructor
     
     Keyword arguments:
     directory -- String containing the name turtle file
     config -- Configuration object, loaded from .ini file
     level -- A logging level as defined in the logging module
     """
     self.config = config
     self.log = logging.getLogger("TabLinker")
     self.log.setLevel(level)
     
     self.graph = ConjunctiveGraph()
     self.log.debug('Loading and parsing file')
     self.graph.parse(filename, format=config.get('general', 'format'))
     
     plugin.register('sparql', rdflib.query.Processor,'rdfextras.sparql.processor', 'Processor')
     plugin.register('sparql', rdflib.query.Result,'rdfextras.sparql.query', 'SPARQLQueryResult')

 def setUp(self):
     register('json-ld',
              Parser,
              'rdflib_jsonld.parser',
              'JsonLDParser')
     # self.graph = Graph()
     self.proj_context_uri = 'http://127.0.0.1:8000/contexts/projects/3.json'
     self.context_file = settings.STATIC_IMPORTS_ROOT + '3-context.json'
     self.data_file = settings.STATIC_IMPORTS_ROOT + 'dt-bone.json'
     self.context_str = self.request_json_str(self.proj_context_uri)
     self.data_str = self.load_json_file_str(self.data_file)
     g_context = ConjunctiveGraph(identifier=self.proj_context_uri)
     g_context.parse(data=self.context_str, format='json-ld')
     proj_graph_obj = URIRef(self.proj_context_uri)
     print('N3: ' + str(g_context.__str__()))
     for c in g_context.contexts():
         print(str(c))
     print('-------Triples for context-graph------')
     self.test_type_linking(g_context)
     g_data = ConjunctiveGraph().parse(data=self.data_str, format='json-ld')
     print('-------Triples for data-record--------')
     self.test_type_linking(g_data)

directly, since it's a plugin. You'll just want to:

>>> import rdflib
>>> import rdflib_schemaorg_csv
>>> g = rdflib.Graph()
>>> g.parse("test.csv", format="schemaorg_csv")
>>> print g.serialize()
"""
import sys
import csv
import StringIO
from rdflib import URIRef, Literal, BNode, Namespace, RDF
from rdflib.plugin import register
from rdflib.parser import Parser

register("schemaorg_csv", Parser, "rdflib_schemaorg_csv", "SchemaOrgCSVParser")


class SchemaOrgCSVParser(Parser):
    NAMESPACES = {
        "schema": Namespace("http://schema.org/"),
        "scsv": Namespace("http://purl.org/NET/schema-org-csv#"),
        "dcterms": Namespace("http://purl.org/dc/terms/"),
    }

    def parse(self, source, sink, **kwargs):
        """
		Pass in a file or file-like object containing CSV with Schema.org
		column headers and populate the sink graph with triples.
		"""
        row_num = 1

import copy
import yaml
import pprint
import os
import json

# setup the ontology
from smart_common.rdf_tools.rdf_ontology import *
from smart_common.rdf_tools.util import bound_graph, URIRef

# setup the json-ld serializer
import rdflib_jsonld_serializer
from rdflib import plugin
from rdflib.serializer import Serializer
plugin.register('json-ld',
                Serializer,
                'rdflib_jsonld_serializer.jsonld_serializer',
                'JsonLDSerializer')

f = None
try:
    f = open(os.getcwd()+'/_config.yml').read()
except:
    raise IOError, "Can't read _config.yml"

if f != None:
    config = yaml.load(f)

SP_STATMENT = "http://smartplatforms.org/terms#Statement"
CONTEXT_URI = config['production_url']+'/reference/data_model/contexts/smart_context.jsonld'

# create smart_jsonld_context, copied from smart_sample_apps

from rdflib import plugin
from rdflib import store

plugin.register('SQLAlchemy', store.Store,
        'rdflib_sqlalchemy.SQLAlchemy', 'SQLAlchemy')