rdflib.Graph.BackwardCompatGraph

Package rdflib :: Module Graph :: Class BackwardCompatGraph

[show private | hide private]

Type BackwardCompatGraph

object --+            
         |            
      Node --+        
             |        
         Graph --+    
                 |    
  ConjunctiveGraph --+
                     |
                    BackwardCompatGraph

Known Subclasses:: TripleStore

Method Summary
	`__init__(self, backend)`
	`__len__(self, context)` Number of triples in the entire graph
	`__reduce__(self)`
	`add(self, (s, p, o), context)` Add to to the given context or to the default context
	`contexts(self, triple)` Iterate over all contexts in the graph
	`get_context(self, identifier, quoted)` Return a context graph for the given identifier
	`objects(self, subject, predicate, context)` Generate objects with the given subject and predicate
	`open(self, configuration, create)` Open the graph store
	`predicate_objects(self, subject, context)` Generate (predicate, object) tuples for the given subject
	`predicates(self, subject, object, context)` Generate predicates with the given subject and object
	`remove(self, (s, p, o), context)` Remove from the given context or from the default context
	`remove_context(self, context)` Remove the given context from the graph
	`save(self, destination, format, base, encoding)`
	`subject_objects(self, predicate, context)` Generate (subject, object) tuples for the given predicate
	`subject_predicates(self, object, context)` Generate (subject, predicate) tuples for the given object
	`subjects(self, predicate, object, context)` Generate subjects with the given predicate and object
	`triples(self, (s, p, o), context)` Iterate over all the triples in the entire graph
Inherited from ConjunctiveGraph
	`__str__(self)`
	`addN(self, quads)` Add a sequence of triple with context
	`context_id(self, uri, context_id)` URI#context
	`parse(self, source, publicID, format, **args)` Parse source into Graph into it's own context (sub graph)
	`quads(self, (s, p, o))` Iterate over all the quads in the entire conjunctive graph
	`triples_choices(self, (s, p, o))` Iterate over all the triples in the entire conjunctive graph
Inherited from Graph
	`__add__(self, other)` Set theoretical union
	`__cmp__(self, other)`
	`__contains__(self, triple)` Support for 'triple in graph' syntax
	`__hash__(self)`
	`__iadd__(self, other)` Add all triples in Graph other to Graph
	`__isub__(self, other)` Subtract all triples in Graph other from Graph
	`__iter__(self)` Iterates over all triples in the store
	`__mul__(self, other)` Set theoretical intersection
	`__repr__(self)`
	`__sub__(self, other)` Set theoretical difference
	`absolutize(self, uri, defrag)` Turn uri into an absolute URI if it's not one already
	`all_nodes(self)`
	`bind(self, prefix, namespace, override)` Bind prefix to namespace
	`close(self, commit_pending_transaction)` Close the graph store
	`comment(self, subject, default)` Query for the RDFS.comment of the subject
	`commit(self)` Commits active transactions
	`compute_qname(self, uri)`
	`connected(self)` Check if the Graph is connected
	`destroy(self, configuration)` Destroy the store identified by `configuration` if supported
	`isomorphic(self, other)`
	`items(self, list)` Generator over all items in the resource specified by list
	`label(self, subject, default)` Query for the RDFS.label of the subject
	`load(self, source, publicID, format)`
	`md5_term_hash(self)`
	`n3(self)` return an n3 identifier for the Graph
	`namespaces(self)` Generator over all the prefix, namespace tuples
	`prepare_input_source(self, source, publicID)`
	`qname(self, uri)`
	`query(self, strOrQuery, initBindings, initNs, DEBUG, processor)` Executes a SPARQL query (eventually will support Versa queries with same method) against this Graph strOrQuery - Is either a string consisting of the SPARQL query or an instance of rdflib.sparql.bison.Query.Query initBindings - A mapping from a Variable to an RDFLib term (used as initial bindings for SPARQL query) initNS - A mapping from a namespace prefix to an instance of rdflib.Namespace (used for SPARQL query) DEBUG - A boolean flag passed on to the SPARQL parser and evaluation engine processor - The kind of RDF query (must be 'sparql' until Versa is ported)
	`rollback(self)` Rollback active transactions
	`seq(self, subject)` Check if subject is an rdf:Seq
	`serialize(self, destination, format, base, encoding, **args)` Serialize the Graph to destination
	`set(self, (subject, predicate, object))` Convenience method to update the value of object
	`transitive_objects(self, subject, property, remember)` Transitively generate objects for the `property` relationship
	`transitive_subjects(self, predicate, object, remember)` Transitively generate objects for the `property` relationship
	`value(self, subject, predicate, object, default, any)` Get a value for a pair of two criteria Exactly one of subject, predicate, object must be None.
Inherited from object
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value

Property Summary
	`backend`
Inherited from Graph
	`identifier`
	`namespace_manager`
	`store`

Class Variable Summary
Inherited from Node
`Implements`	`__implemented__` = `<implementedBy rdflib.Node.Node>`
`ClassProvides`	`__providedBy__` = `<zope.interface.declarations.ClassProvi...`
`ClassProvides`	`__provides__` = `<zope.interface.declarations.ClassProvide...`
`tuple`	`__slots__` = `()`