rdflib.Graph.ReadOnlyGraphAggregate

Package rdflib :: Module Graph :: Class ReadOnlyGraphAggregate

[show private | hide private]

Type ReadOnlyGraphAggregate

object --+            
         |            
      Node --+        
             |        
         Graph --+    
                 |    
  ConjunctiveGraph --+
                     |
                    ReadOnlyGraphAggregate

Utility class for treating a set of graphs as a single graph

Only read operations are supported (hence the name). Essentially a ConjunctiveGraph over an explicit subset of the entire store.

Method Summary
	`__init__(self, graphs, store)`
	`__cmp__(self, other)`
	`__hash__(self)`
	`__iadd__(self, other)` Add all triples in Graph other to Graph
	`__isub__(self, other)` Subtract all triples in Graph other from Graph
	`__len__(self)` Number of triples in the entire conjunctive graph
	`__reduce__(self)`
	`__repr__(self)`
	`absolutize(self, uri, defrag)` Turn uri into an absolute URI if it's not one already
	`add(self, (s, p, o))` Add the triple to the default context
	`addN(self, quads)` Add a sequence of triple with context
	`bind(self, prefix, namespace, override)` Bind prefix to namespace
	`close(self)`
	`commit(self)` Commits active transactions
	`compute_qname(self, uri)`
	`destroy(self, configuration)` Destroy the store identified by `configuration` if supported
	`n3(self)` return an n3 identifier for the Graph
	`namespaces(self)` Generator over all the prefix, namespace tuples
	`open(self, configuration, create)` Open the graph store
	`parse(self, source, publicID, format, **args)` Parse source into Graph into it's own context (sub graph)
	`qname(self, uri)`
	`quads(self, (s, p, o))` Iterate over all the quads in the entire aggregate graph
	`remove(self, (s, p, o))` Removes from all its contexts
	`rollback(self)` Rollback active transactions
	`triples(self, (s, p, o))` Iterate over all the triples in the entire conjunctive graph
	`triples_choices(self, (subject, predicate, object_), context)`
Inherited from ConjunctiveGraph
	`__str__(self)`
	`context_id(self, uri, context_id)` URI#context
	`contexts(self, triple)` Iterate over all contexts in the graph
	`remove_context(self, context)` Removes the given context from the graph
Inherited from Graph
	`__add__(self, other)` Set theoretical union
	`__contains__(self, triple)` Support for 'triple in graph' syntax
	`__iter__(self)` Iterates over all triples in the store
	`__mul__(self, other)` Set theoretical intersection
	`__sub__(self, other)` Set theoretical difference
	`all_nodes(self)`
	`comment(self, subject, default)` Query for the RDFS.comment of the subject
	`connected(self)` Check if the Graph is connected
	`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)`
	`objects(self, subject, predicate)` A generator of objects with the given subject and predicate
	`predicate_objects(self, subject)` A generator of (predicate, object) tuples for the given subject
	`predicates(self, subject, object)` A generator of predicates with the given subject and object
	`prepare_input_source(self, source, publicID)`
	`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)
	`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
	`subject_objects(self, predicate)` A generator of (subject, object) tuples for the given predicate
	`subject_predicates(self, object)` A generator of (subject, predicate) tuples for the given object
	`subjects(self, predicate, object)` A generator of subjects with the given predicate and 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.
	`_get_namespace_manager(self)`
	`_set_namespace_manager(self, nm)`
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
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__` = `()`

Method Details

iadd(self, other)

Add all triples in Graph other to Graph

Overrides:: rdflib.Graph.Graph.__iadd__ (inherited documentation)

isub(self, other)

Subtract all triples in Graph other from Graph

Overrides:: rdflib.Graph.Graph.__isub__ (inherited documentation)

len(self)
(Length operator)

Number of triples in the entire conjunctive graph

Overrides:: rdflib.Graph.ConjunctiveGraph.__len__ (inherited documentation)

absolutize(self, uri, defrag=1)

Turn uri into an absolute URI if it's not one already

Overrides:: rdflib.Graph.Graph.absolutize (inherited documentation)

add(self, (s, p, o))

Add the triple to the default context

Overrides:: rdflib.Graph.ConjunctiveGraph.add (inherited documentation)

addN(self, quads)

Add a sequence of triple with context

Overrides:: rdflib.Graph.ConjunctiveGraph.addN (inherited documentation)

bind(self, prefix, namespace, override=True)

Bind prefix to namespace

If override is True will bind namespace to given prefix if namespace was already bound to a different prefix.

Overrides:: rdflib.Graph.Graph.bind (inherited documentation)

commit(self)

Commits active transactions

Overrides:: rdflib.Graph.Graph.commit (inherited documentation)

destroy(self, configuration)

Destroy the store identified by `configuration` if supported

Overrides:: rdflib.Graph.Graph.destroy (inherited documentation)

n3(self)

return an n3 identifier for the Graph

Overrides:: rdflib.Graph.Graph.n3 (inherited documentation)

namespaces(self)

Generator over all the prefix, namespace tuples

Overrides:: rdflib.Graph.Graph.namespaces (inherited documentation)

open(self, configuration, create=False)

Open the graph store

Might be necessary for stores that require opening a connection to a database or acquiring some resource.

Overrides:: rdflib.Graph.Graph.open (inherited documentation)

parse(self, source, publicID=None, format='xml', **args)

Parse source into Graph into it's own context (sub graph)

Format defaults to xml (AKA rdf/xml). The publicID argument is for specifying the logical URI for the case that it's different from the physical source URI. Returns the context into which the source was parsed. In the case of n3 it returns the root context.

Overrides:: rdflib.Graph.ConjunctiveGraph.parse (inherited documentation)

quads(self, (s, p, o))

Iterate over all the quads in the entire aggregate graph

Overrides:: rdflib.Graph.ConjunctiveGraph.quads

remove(self, (s, p, o))

Removes from all its contexts

Overrides:: rdflib.Graph.ConjunctiveGraph.remove (inherited documentation)

rollback(self)

Rollback active transactions

Overrides:: rdflib.Graph.Graph.rollback (inherited documentation)

triples(self, (s, p, o))

Iterate over all the triples in the entire conjunctive graph

Overrides:: rdflib.Graph.ConjunctiveGraph.triples (inherited documentation)

Generated by Epydoc 2.1 on Wed Apr 4 16:05:47 2007

http://epydoc.sf.net