Ejemplo n.º 1
0
class ReaderPlugin(RDFQueryReader):
    def __init__(self, *args, **kwargs):
        super(ReaderPlugin, self).__init__(*args, **kwargs)

        self._rdflib_store = kwargs.get("rdflib_store", "IOMemory")
        self._rdflib_identifier = kwargs.get("rdflib_identifier")
        self._commit_pending_transaction_on_close = \
            kwargs.get("commit_pending_transaction_on_close", True)

        self._graph = ConjunctiveGraph(
            store=self._rdflib_store,
            identifier=self._rdflib_identifier
        )

    @property
    def rdflib_store(self):
        return self._rdflib_store

    @property
    def rdflib_identifier(self):
        return self._rdflib_identifier

    @property
    def graph(self):
        return self._graph

    @property
    def commit_pending_transaction_on_close(self):
        return self._commit_pending_transaction_on_close

    def _to_table(self, result):
        # Elements in result.selectionF are instances of rdflib.Variable,
        # rdflib.Variable is subclass of unicode. We convert them to 
        # unicode here anyway to hide rdflib internals from clients. 
        vars = [unicode(var) for var in result.vars]

        # Convert each row to dict: { var->value, ... }
        return [dict(zip(vars, row)) for row in result]

    def _ask(self, result):
        # askAnswer is list with boolean values, we want first value. 
        return result.askAnswer[0]

    def _execute(self, query):
        q_string = unicode(query)
        debug(q_string)
        return self._graph.query(q_string)

    def execute_sparql(self, q_string, format=None):
        debug(q_string)

        result = self._graph.query(q_string)
        return loads(result.serialize(format='json'))

    def close(self):
        self._graph.close(commit_pending_transaction=self._commit_pending_transaction_on_close)
Ejemplo n.º 2
0
class ReaderPlugin(RDFQueryReader):
    def __init__(self, *args, **kwargs):
        super(ReaderPlugin, self).__init__(*args, **kwargs)

        self._rdflib_store = kwargs.get("rdflib_store", "IOMemory")
        self._rdflib_identifier = kwargs.get("rdflib_identifier")
        self._commit_pending_transaction_on_close = \
            kwargs.get("commit_pending_transaction_on_close", True)

        self._graph = ConjunctiveGraph(
            store=self._rdflib_store,
            identifier=self._rdflib_identifier
        )

    @property
    def rdflib_store(self):
        return self._rdflib_store

    @property
    def rdflib_identifier(self):
        return self._rdflib_identifier

    @property
    def graph(self):
        return self._graph

    @property
    def commit_pending_transaction_on_close(self):
        return self._commit_pending_transaction_on_close

    def _to_table(self, result):
        # Elements in result.selectionF are instances of rdflib.Variable,
        # rdflib.Variable is subclass of unicode. We convert them to 
        # unicode here anyway to hide rdflib internals from clients. 
        vars = [str(var) for var in result.vars]

        # Convert each row to dict: { var->value, ... }
        return [dict(list(zip(vars, row))) for row in result]

    def _ask(self, result):
        # askAnswer is list with boolean values, we want first value. 
        return result.askAnswer[0]

    def _execute(self, query):
        q_string = str(query)
        debug(q_string)
        return self._graph.query(q_string)

    def execute_sparql(self, q_string, format=None):
        debug(q_string)

        result = self._graph.query(q_string)
        return loads(result.serialize(format='json'))

    def close(self):
        self._graph.close(commit_pending_transaction=self._commit_pending_transaction_on_close)
Ejemplo n.º 3
0
    def __init__(self, *args, **kwargs):
        super(ReaderPlugin, self).__init__(*args, **kwargs)

        self._rdflib_store = kwargs.get("rdflib_store", "IOMemory")
        self._rdflib_identifier = kwargs.get("rdflib_identifier")
        self._commit_pending_transaction_on_close = \
            kwargs.get("commit_pending_transaction_on_close", True)

        self._graph = ConjunctiveGraph(store=self._rdflib_store,
                                       identifier=self._rdflib_identifier)
Ejemplo n.º 4
0
    def load_from_source(self, data=None, file=None, location=None, format=None):
        """
        Load the `resource` from a source (uri, file or string rdf data).

        """

        graph = ConjunctiveGraph()
        if format is None:
            format = "application/rdf+xml"
        elif format in self.formats:
            format = self.formats[format]
        graph.parse(data=data, file=file, location=location, format=format)
        self.set(graph)
Ejemplo n.º 5
0
    def load_from_source(self,
                         data=None,
                         file=None,
                         location=None,
                         format=None):
        """
        Load the `resource` from a source (uri, file or string rdf data).

        """

        graph = ConjunctiveGraph()
        if format is None:
            format = 'application/rdf+xml'
        elif format in self.formats:
            format = self.formats[format]
        graph.parse(data=data, file=file, location=location, format=format)
        self.set(graph)
Ejemplo n.º 6
0
    def __init__(self, *args, **kwargs):
        RDFQueryReader.__init__(self, *args, **kwargs)

        self.__rdflib_store = kwargs.get("rdflib_store", "IOMemory")
        self.__rdflib_identifier = kwargs.get("rdflib_identifier") 
        self.__commit_pending_transaction_on_close = \
            kwargs.get("commit_pending_transaction_on_close", True)

        self.__graph = ConjunctiveGraph(store = self.__rdflib_store,
                                        identifier = self.__rdflib_identifier)
Ejemplo n.º 7
0
    def __init__(self, reader, *args, **kwargs):
        RDFWriter.__init__(self, reader, *args, **kwargs)
        if isinstance(self.reader, ReaderPlugin):
            self.__rdflib_store = self.reader.rdflib_store
            self.__rdflib_identifier = self.reader.rdflib_identifier
            self.__commit_pending_transaction_on_close = \
                self.reader.commit_pending_transaction_on_close

            self.__graph = self.reader.graph
        else:
            self.__rdflib_store = kwargs.get("rdflib_store", "IOMemory")
            self.__rdflib_identifier = kwargs.get("rdflib_identifier")
            self.__commit_pending_transaction_on_close = \
                kwargs.get("commit_pending_transaction_on_close", True)

            self.__graph = ConjunctiveGraph(
                store=self.__rdflib_store, identifier=self.__rdflib_identifier)

            warnings.warn("Graph is not readable through the reader plugin",
                          UserWarning)
Ejemplo n.º 8
0
    def __deserialize(self, response):
        '''
        serializes the response based on the Content-Type or Accept header
        '''
        content_type = response.getheader('Content-type')
        content = response.read()

        format = 'text'
        if isinstance(content_type, str):
            for type, mimetype in Sesame2.response_format.items():
                if content_type.startswith(mimetype):
                    format = type
        
        ser_content = content
        if format in ['nt', 'xml', 'n3', 'turtle']:
            graph = ConjunctiveGraph()
            ser_content = graph.parse(data = content, format = format)
        elif format in ['sparql']:
            ser_content = parse_sparql_xml(content)
        return ser_content
Ejemplo n.º 9
0
    def __deserialize(self, response):
        '''
        serializes the response based on the Content-Type or Accept header
        '''
        content_type = response.getheader('Content-type')
        content = response.read()

        format = 'text'
        if isinstance(content_type, str):
            for type, mimetype in Sesame2.response_format.items():
                if content_type.startswith(mimetype):
                    format = type

        ser_content = content
        if format in ['nt', 'xml', 'n3', 'turtle']:
            graph = ConjunctiveGraph()
            ser_content = graph.parse(data=content, format=format)
        elif format in ['sparql']:
            ser_content = parse_sparql_xml(content)
        elif format in ['sparql+json']:
            ser_content = loads(content)
        return ser_content
Ejemplo n.º 10
0
class ReaderPlugin(RDFQueryReader):
    def __init__(self, *args, **kwargs):
        RDFQueryReader.__init__(self, *args, **kwargs)

        self.__rdflib_store = kwargs.get("rdflib_store", "IOMemory")
        self.__rdflib_identifier = kwargs.get("rdflib_identifier") 
        self.__commit_pending_transaction_on_close = \
            kwargs.get("commit_pending_transaction_on_close", True)

        self.__graph = ConjunctiveGraph(store = self.__rdflib_store,
                                        identifier = self.__rdflib_identifier)

    rdflib_store = property(lambda self: self.__rdflib_store)
    rdflib_identifier = property(lambda self: self.__rdflib_identifier)
    graph = property(lambda self: self.__graph)
    commit_pending_transaction_on_close = \
        property(lambda self: self.__commit_pending_transaction_on_close)

    def _to_table(self, result):
        vars = [unicode(var) for var in result.selectionF]
        def row_to_dict(row):
            return dict([ (vars[i], row[i]) for i in range(len(row)) ])
        return [ row_to_dict(row) for row in result ]

    def _ask(self, result):
        # askAnswer is list with boolean values, we want first value. 
        return result.askAnswer[0]

    # execute
    def _execute(self, query):
        return self.execute_sparql(unicode(query))

    def execute_sparql(self, q_string, format = None):
        self.log.debug(q_string)
        return self.__graph.query(q_string)

    def close(self):
        self.__graph.close(commit_pending_transaction = self.__commit_pending_transaction_on_close)
Ejemplo n.º 11
0
    def graph(self, direct=True):
        """
        Return an `rdflib` `ConjunctiveGraph` represenation of the current `resource`

        """

        graph = ConjunctiveGraph()
        self.bind_namespaces_to_graph(graph)
        graph.add((self.subject, RDF['type'], self.uri))
        for predicate in self.__rdf_direct:
            for value in self.__rdf_direct[predicate]:
                if isinstance(value, (URIRef, Literal, BNode)):
                    graph.add((self.subject, predicate, value))
        if not direct:
            for predicate in self.__rdf_inverse:
                for value in self.__rdf_inverse[predicate]:
                    if isinstance(value, (URIRef, Literal, BNode)):
                        graph.add((value, predicate, self.subject))
        return graph
Ejemplo n.º 12
0
    def __init__(self, reader, *args, **kwargs):
        RDFWriter.__init__(self, reader, *args, **kwargs)
        if isinstance(self.reader, ReaderPlugin):
            self.__rdflib_store = self.reader.rdflib_store
            self.__rdflib_identifier = self.reader.rdflib_identifier
            self.__commit_pending_transaction_on_close = \
                self.reader.commit_pending_transaction_on_close

            self.__graph = self.reader.graph
        else:
            self.__rdflib_store = kwargs.get("rdflib_store", "IOMemory")
            self.__rdflib_identifier = kwargs.get("rdflib_identifier") 
            self.__commit_pending_transaction_on_close = \
                kwargs.get("commit_pending_transaction_on_close", True)

            self.__graph = ConjunctiveGraph(store = self.__rdflib_store, identifier = self.__rdflib_identifier)

            warnings.warn("Graph is not readable through the reader plugin", 
                          UserWarning)
Ejemplo n.º 13
0
    def graph(self, direct = True):
        """
        Return an `rdflib` `ConjunctiveGraph` represenation of the current `resource`

        """

        graph = ConjunctiveGraph()
        self.bind_namespaces_to_graph(graph)
        graph.add((self.subject, RDF['type'], self.uri))
        for predicate in self.__rdf_direct:
            for value in self.__rdf_direct[predicate]:
                if type(value) in [URIRef, Literal, BNode]:
                    graph.add((self.subject, predicate, value))
        if not direct:
            for predicate in self.__rdf_inverse:
                for value in self.__rdf_inverse[predicate]:
                    if type(value) in [URIRef, Literal, BNode]:
                        graph.add((value, predicate, self.subject))
        return graph
Ejemplo n.º 14
0
class WriterPlugin(RDFWriter):
    def __init__(self, reader, *args, **kwargs):
        super(WriterPlugin, self).__init__(reader, *args, **kwargs)

        if isinstance(self.reader, ReaderPlugin):
            self._rdflib_store = self.reader.rdflib_store
            self._rdflib_identifier = self.reader.rdflib_identifier
            self._commit_pending_transaction_on_close = \
                self.reader.commit_pending_transaction_on_close

            self._graph = self.reader.graph
        else:
            self._rdflib_store = kwargs.get("rdflib_store", "IOMemory")
            self._rdflib_identifier = kwargs.get("rdflib_identifier")
            self._commit_pending_transaction_on_close = \
                kwargs.get("commit_pending_transaction_on_close", True)

            self._graph = ConjunctiveGraph(store=self._rdflib_store,
                                           identifier=self._rdflib_identifier)

            warnings.warn("Graph is not readable through the reader plugin",
                          UserWarning)

    @property
    def rdflib_store(self):
        return self._rdflib_store

    @property
    def rdflib_identifier(self):
        return self._rdflib_identifier

    @property
    def graph(self):
        return self._graph

    @property
    def commit_pending_transaction_on_close(self):
        return self._commit_pending_transaction_on_close

    def _save(self, *resources):
        for resource in resources:
            s = resource.subject
            self._remove_from_graph(s)
            for p, objs in list(resource.rdf_direct.items()):
                for o in objs:
                    self.__add(s, p, o)

        self._graph.commit()

    def _update(self, *resources):
        for resource in resources:
            s = resource.subject
            for p in resource.rdf_direct:
                self._remove_from_graph(s, p)
            for p, objs in list(resource.rdf_direct.items()):
                for o in objs:
                    self.__add(s, p, o)

        self._graph.commit()

    def _remove(self, *resources, **kwargs):
        inverse = kwargs.get("inverse")
        for resource in resources:
            self._remove_from_graph(s=resource.subject)
            if inverse:
                self._remove_from_graph(o=resource.subject)

        self._graph.commit()

    def _size(self):
        return len(self._graph)

    def _add_triple(self, s=None, p=None, o=None, context=None):
        self.__add(s, p, o, context)

    def _set_triple(self, s=None, p=None, o=None, context=None):
        self._remove_from_graph(s, p, context=context)
        self.__add(s, p, o, context)

    def _remove_triple(self, s=None, p=None, o=None, context=None):
        self._remove_from_graph(s, p, o, context)

    def __add(self, s=None, p=None, o=None, context=None):
        info('ADD: %s, %s, %s, %s' % (s, p, o, context))
        self._graph.add((s, p, o))

    def _remove_from_graph(self, s=None, p=None, o=None, context=None):
        info('REM: %s, %s, %s, %s' % (s, p, o, context))
        self._graph.remove((s, p, o))

    def index_triples(self, **kwargs):
        """
        Index triples if this functionality is present.
        
        :return: True if successful
        :rtype: bool
        """
        # TODO: can indexing be forced ?
        return False

    def load_triples(self, source=None, public_id=None, format="xml", **args):
        """
        Load files (or resources on the web) into the triple-store.

        :param str source: the source file to load RDF triples from
        :param public_id: the :mod:`rdflib` publicID
        :param str format: the source file format
        :param dict args: extra args passed to :meth:`rdflib.graph.Graph.parse`
        :return: True if successful
        :rtype: bool
        """
        if source is not None:
            debug("have %s triples, loading ...", len(self._graph))
            self._graph.parse(source,
                              publicID=public_id,
                              format=format,
                              **args)
            debug("load complete; have %s triples", len(self._graph))
            return True

        return False

    def _clear(self, context=None):
        """
        Clear the triple-store.
        """
        self._graph.remove((None, None, None))

    def close(self):
        self._graph.close(commit_pending_transaction=self.
                          _commit_pending_transaction_on_close)
Ejemplo n.º 15
0
class WriterPlugin(RDFWriter):
    def __init__(self, reader, *args, **kwargs):
        RDFWriter.__init__(self, reader, *args, **kwargs)
        if isinstance(self.reader, ReaderPlugin):
            self.__rdflib_store = self.reader.rdflib_store
            self.__rdflib_identifier = self.reader.rdflib_identifier
            self.__commit_pending_transaction_on_close = \
                self.reader.commit_pending_transaction_on_close

            self.__graph = self.reader.graph
        else:
            self.__rdflib_store = kwargs.get("rdflib_store", "IOMemory")
            self.__rdflib_identifier = kwargs.get("rdflib_identifier")
            self.__commit_pending_transaction_on_close = \
                kwargs.get("commit_pending_transaction_on_close", True)

            self.__graph = ConjunctiveGraph(
                store=self.__rdflib_store, identifier=self.__rdflib_identifier)

            warnings.warn("Graph is not readable through the reader plugin",
                          UserWarning)

    rdflib_store = property(lambda self: self.__rdflib_store)
    rdflib_identifier = property(lambda self: self.__rdflib_identifier)
    graph = property(lambda self: self.__graph)
    commit_pending_transaction_on_close = \
        property(lambda self: self.__commit_pending_transaction_on_close)

    def _save(self, *resources):
        for resource in resources:
            s = resource.subject
            self.__remove(s)
            for p, objs in resource.rdf_direct.items():
                for o in objs:
                    self.__add(s, p, o)

        self.__graph.commit()

    def _update(self, *resources):
        for resource in resources:
            s = resource.subject
            for p in resource.rdf_direct:
                self.__remove(s, p)
            for p, objs in resource.rdf_direct.items():
                for o in objs:
                    self.__add(s, p, o)

        self.__graph.commit()

    def _remove(self, *resources, **kwargs):
        inverse = kwargs.get("inverse")
        for resource in resources:
            self.__remove(s=resource.subject)
            if inverse:
                self.__remove(o=resource.subject)

        self.__graph.commit()

    def _size(self):
        return len(self.__graph)

    def _add_triple(self, s=None, p=None, o=None, context=None):
        self.__add(s, p, o, context)

    def _set_triple(self, s=None, p=None, o=None, context=None):
        self.__remove(s, p, context=context)
        self.__add(s, p, o, context)

    def _remove_triple(self, s=None, p=None, o=None, context=None):
        self.__remove(s, p, o, context)

    def __add(self, s=None, p=None, o=None, context=None):
        self.log.info('ADD: %s, %s, %s, %s' % (s, p, o, context))
        self.__graph.add((s, p, o))

    def __remove(self, s=None, p=None, o=None, context=None):
        self.log.info('REM: %s, %s, %s, %s' % (s, p, o, context))
        self.__graph.remove((s, p, o))

    def index_triples(self, **kwargs):
        """ Index triples if this functionality is present.  
        
        Return `True` if successful.
        
        """

        # TODO: can indexing be forced ?
        return True

    def load_triples(self, source=None, publicID=None, format="xml", **args):
        """ Load files (or resources on the web) into the triple-store. """

        if source:
            self.__graph.parse(source,
                               publicID=publicID,
                               format=format,
                               **args)
            return True

        return False

    def _clear(self, context=None):
        """ Clear the triple-store. """

        self.__graph.remove((None, None, None))

    def close(self):
        self.__graph.close(commit_pending_transaction=self.
                           __commit_pending_transaction_on_close)
Ejemplo n.º 16
0
class WriterPlugin(RDFWriter):
    def __init__(self, reader, *args, **kwargs):
        super(WriterPlugin, self).__init__(reader, *args, **kwargs)

        if isinstance(self.reader, ReaderPlugin):
            self._rdflib_store = self.reader.rdflib_store
            self._rdflib_identifier = self.reader.rdflib_identifier
            self._commit_pending_transaction_on_close = \
                self.reader.commit_pending_transaction_on_close

            self._graph = self.reader.graph
        else:
            self._rdflib_store = kwargs.get("rdflib_store", "IOMemory")
            self._rdflib_identifier = kwargs.get("rdflib_identifier")
            self._commit_pending_transaction_on_close = \
                kwargs.get("commit_pending_transaction_on_close", True)

            self._graph = ConjunctiveGraph(store=self._rdflib_store, identifier=self._rdflib_identifier)

            warnings.warn("Graph is not readable through the reader plugin", UserWarning)

    @property
    def rdflib_store(self):
        return self._rdflib_store

    @property
    def rdflib_identifier(self):
        return self._rdflib_identifier

    @property
    def graph(self):
        return self._graph

    @property
    def commit_pending_transaction_on_close(self):
        return self._commit_pending_transaction_on_close

    def _save(self, *resources):
        for resource in resources:
            s = resource.subject
            self._remove_from_graph(s)
            for p, objs in resource.rdf_direct.items():
                for o in objs:
                    self.__add(s, p, o)

        self._graph.commit()

    def _update(self, *resources):
        for resource in resources:
            s = resource.subject
            for p in resource.rdf_direct:
                self._remove_from_graph(s, p)
            for p, objs in resource.rdf_direct.items():
                for o in objs:
                    self.__add(s, p, o)

        self._graph.commit()

    def _remove(self, *resources, **kwargs):
        inverse = kwargs.get("inverse")
        for resource in resources:
            self._remove_from_graph(s=resource.subject)
            if inverse:
                self._remove_from_graph(o=resource.subject)

        self._graph.commit()

    def _size(self):
        return len(self._graph)

    def _add_triple(self, s=None, p=None, o=None, context=None):
        self.__add(s, p, o, context)

    def _set_triple(self, s=None, p=None, o=None, context=None):
        self._remove_from_graph(s, p, context=context)
        self.__add(s, p, o, context)

    def _remove_triple(self, s=None, p=None, o=None, context=None):
        self._remove_from_graph(s, p, o, context)

    def __add(self, s=None, p=None, o=None, context=None):
        info('ADD: %s, %s, %s, %s' % (s, p, o, context))
        self._graph.add((s, p, o))

    def _remove_from_graph(self, s=None, p=None, o=None, context=None):
        info('REM: %s, %s, %s, %s' % (s, p, o, context))
        self._graph.remove((s, p, o))

    def index_triples(self, **kwargs):
        """
        Index triples if this functionality is present.
        
        :return: True if successful
        :rtype: bool
        """
        # TODO: can indexing be forced ?
        return False

    def load_triples(self, source=None, public_id=None, format="xml", **args):
        """
        Load files (or resources on the web) into the triple-store.

        :param str source: the source file to load RDF triples from
        :param public_id: the :mod:`rdflib` publicID
        :param str format: the source file format
        :param dict args: extra args passed to :meth:`rdflib.graph.Graph.parse`
        :return: True if successful
        :rtype: bool
        """
        if source is not None:
            debug("have %s triples, loading ...", len(self._graph))
            self._graph.parse(source, publicID=public_id, format=format, **args)
            debug("load complete; have %s triples", len(self._graph))
            return True

        return False

    def _clear(self, context=None):
        """
        Clear the triple-store.
        """
        self._graph.remove((None, None, None))

    def close(self):
        self._graph.close(commit_pending_transaction=self._commit_pending_transaction_on_close)
Ejemplo n.º 17
0
class WriterPlugin(RDFWriter):
    def __init__(self, reader, *args, **kwargs):
        RDFWriter.__init__(self, reader, *args, **kwargs)
        if isinstance(self.reader, ReaderPlugin):
            self.__rdflib_store = self.reader.rdflib_store
            self.__rdflib_identifier = self.reader.rdflib_identifier
            self.__commit_pending_transaction_on_close = \
                self.reader.commit_pending_transaction_on_close

            self.__graph = self.reader.graph
        else:
            self.__rdflib_store = kwargs.get("rdflib_store", "IOMemory")
            self.__rdflib_identifier = kwargs.get("rdflib_identifier") 
            self.__commit_pending_transaction_on_close = \
                kwargs.get("commit_pending_transaction_on_close", True)

            self.__graph = ConjunctiveGraph(store = self.__rdflib_store, identifier = self.__rdflib_identifier)

            warnings.warn("Graph is not readable through the reader plugin", 
                          UserWarning)

    rdflib_store = property(lambda self: self.__rdflib_store)
    rdflib_identifier = property(lambda self: self.__rdflib_identifier)
    graph = property(lambda self: self.__graph)
    commit_pending_transaction_on_close = \
        property(lambda self: self.__commit_pending_transaction_on_close)


    def _save(self, *resources):
        for resource in resources:
            s = resource.subject
            self.__remove(s)
            for p, objs in resource.rdf_direct.items():
                for o in objs:
                    self.__add(s, p, o)

        self.__graph.commit()

    def _update(self, *resources):
        for resource in resources:
            s = resource.subject
            for p in resource.rdf_direct:
                self.__remove(s, p)
            for p, objs in resource.rdf_direct.items():
                for o in objs:
                    self.__add(s, p, o)

        self.__graph.commit()

    def _remove(self, *resources, **kwargs):
        inverse = kwargs.get("inverse")
        for resource in resources:
            self.__remove(s = resource.subject)
            if inverse:
                self.__remove(o = resource.subject)
            

    def _size(self):
        return len(self.__graph)

    def _add_triple(self, s = None, p = None, o = None, context = None):
        self.__add(s, p, o, context)

    def _set_triple(self, s = None, p = None, o = None, context = None):
        self.__remove(s, p, context = context)
        self.__add(s, p, o, context)

    def _remove_triple(self, s = None, p = None, o = None, context = None):
        self.__remove(s, p, o, context)

    def __add(self, s = None, p = None, o = None, context = None):
        self.log.info('ADD : ' + str(s) + ', ' + str(p) + ', ' + str(o) + ', ' + str(context))
        self.__graph.add((s, p, o))

    def __remove(self, s = None, p = None, o = None, context = None):
        self.log.info('REM : ' + str(s) + ', ' + str(p) + ', ' + str(o) + ', ' + str(context))
        self.__graph.remove((s, p, o))

    def index_triples(self, **kwargs):
        """ Index triples if this functionality is present.  
        
        Return `True` if successful.
        
        """

        # TODO: can indexing be forced ?
        return True

    def load_triples(self, source = None, publicID = None, format = "xml", **args):
        """ Load files (or resources on the web) into the triple-store.
        
        This method is kept for backward compatibility only.
        
        """
        
        if source:
            self.__graph.parse(source, publicID = publicID, format = format, **args)
            return True
        
        return False

    def _clear(self, context = None):
        """ Clear the triple-store. """

        self.__graph.remove((None, None, None))

    def close(self):
        self.__graph.close(commit_pending_transaction = self.__commit_pending_transaction_on_close)