rdflib.sparql.sparqlGraph.SPARQLGraph

Package rdflib :: Package sparql :: Module sparqlGraph :: Class SPARQLGraph

[show private | hide private]

Type SPARQLGraph

object --+        
         |        
      Node --+    
             |    
         Graph --+
                 |
                SPARQLGraph

A subclass of Graph with a few extra SPARQL bits.

Method Summary
	`__init__(self, graph, graphVariable)`
`sparqlGraph`	`cluster(self, seed)` Cluster up and down, by summing up the forward and backward clustering
`sparqlGraph`	`clusterBackward(self, seed, Cluster)` Cluster the triple store: from a seed, transitively get all properties and objects 'backward', ie, following the link back in the graph.
`sparqlGraph`	`clusterForward(self, seed, Cluster)` Cluster the triple store: from a seed, transitively get all properties and objects in direction of the arcs.
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
	`__len__(self)` Returns the number of triples in the graph
	`__mul__(self, other)` Set theoretical intersection
	`__reduce__(self)`
	`__repr__(self)`
	`__str__(self)`
	`__sub__(self, other)` Set theoretical difference
	`absolutize(self, uri, defrag)` Turn uri into an absolute URI if it's not one already
	`add(self, (s, p, o))` Add a triple with self as context
	`addN(self, quads)` Add a sequence of triple with context
	`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
	`objects(self, subject, predicate)` A generator of objects with the given subject and predicate
	`open(self, configuration, create)` Open the graph store
	`parse(self, source, publicID, format, **args)` Parse source into Graph
	`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)`
	`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)
	`remove(self, (s, p, o))` Remove a triple from the graph
	`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
	`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
	`triples(self, (s, p, o))` Generator over the triple store
	`triples_choices(self, (subject, predicate, object_), context)`
	`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
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

cluster(self, seed)

Cluster up and down, by summing up the forward and backward clustering

Parameters:: seed - RDFLib Resource

Returns:: The triple store containing the cluster
(type=sparqlGraph)

clusterBackward(self, seed, Cluster=None)

Cluster the triple store: from a seed, transitively get all properties and objects 'backward', ie, following the link back in the graph.

Parameters:: seed - RDFLib Resource; Cluster - another sparqlGraph instance; if None, a new one will be created. The subgraph will be added to this graph.

Returns:: The triple store containing the cluster
(type=sparqlGraph)

clusterForward(self, seed, Cluster=None)

Cluster the triple store: from a seed, transitively get all properties and objects in direction of the arcs.

Parameters:: seed - RDFLib Resource; Cluster - another sparqlGraph instance; if None, a new one will be created. The subgraph will be added to this graph.

Returns:: The triple store containing the cluster
(type=sparqlGraph)

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

http://epydoc.sf.net