3 d@s"ddlmZddlmZddlmZddlmZes8tddlmZesLtdZ ddl Z e j e Z ddlZddlmZmZmZdd lmZmZmZdd lmZmZmZdd lmZddlZdd lmZdd lmZddlmZddl m!Z!ddl m"Z"ddlm#Z#ddl$m%Z%ddl&m'Z'ddl(Z(ddl)Z)ddl*Z*ddl+m,Z,ddl+m-Z-ddl.m/Z/ddddddddgZ0GdddeZ1Gd dde1Z2ed!Z3Gd"dde2Z4Gd#dde1Z5d$ej6j7e5<Gd%dde8Z9Gd&dde:Z;Gd'dde:Zd+d,Z?e d-kre?dS).)absolute_import)division)print_function)Literal) NamespaceaH RDFLib defines the following kinds of Graphs: * :class:`~rdflib.graph.Graph` * :class:`~rdflib.graph.QuotedGraph` * :class:`~rdflib.graph.ConjunctiveGraph` * :class:`~rdflib.graph.Dataset` Graph ----- An RDF graph is a set of RDF triples. Graphs support the python ``in`` operator, as well as iteration and some operations like union, difference and intersection. see :class:`~rdflib.graph.Graph` Conjunctive Graph ----------------- A Conjunctive Graph is the most relevant collection of graphs that are considered to be the boundary for closed world assumptions. This boundary is equivalent to that of the store instance (which is itself uniquely identified and distinct from other instances of :class:`Store` that signify other Conjunctive Graphs). It is equivalent to all the named graphs within it and associated with a ``_default_`` graph which is automatically assigned a :class:`BNode` for an identifier - if one isn't given. see :class:`~rdflib.graph.ConjunctiveGraph` Quoted graph ------------ The notion of an RDF graph [14] is extended to include the concept of a formula node. A formula node may occur wherever any other kind of node can appear. Associated with a formula node is an RDF graph that is completely disjoint from all other graphs; i.e. has no nodes in common with any other graph. (It may contain the same labels as other RDF graphs; because this is, by definition, a separate graph, considerations of tidiness do not apply between the graph at a formula node and any other graph.) This is intended to map the idea of "{ N3-expression }" that is used by N3 into an RDF graph upon which RDF semantics is defined. see :class:`~rdflib.graph.QuotedGraph` Dataset ------- The RDF 1.1 Dataset, a small extension to the Conjunctive Graph. The primary term is "graphs in the datasets" and not "contexts with quads" so there is a separate method to set/retrieve a graph in a dataset and to operate with dataset graphs. As a consequence of this approach, dataset graphs cannot be identified with blank nodes, a name is always required (RDFLib will automatically add a name if one is not provided at creation time). This implementation includes a convenience method to directly add a single quad to a dataset graph. see :class:`~rdflib.graph.Dataset` Working with graphs =================== Instantiating Graphs with default store (IOMemory) and default identifier (a BNode): >>> g = Graph() >>> g.store.__class__ >>> g.identifier.__class__ Instantiating Graphs with a IOMemory store and an identifier - : >>> g = Graph('IOMemory', URIRef("http://rdflib.net")) >>> g.identifier rdflib.term.URIRef('http://rdflib.net') >>> str(g) # doctest: +NORMALIZE_WHITESPACE " a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'IOMemory']." Creating a ConjunctiveGraph - The top level container for all named Graphs in a "database": >>> g = ConjunctiveGraph() >>> str(g.default_context) "[a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'IOMemory']]." Adding / removing reified triples to Graph and iterating over it directly or via triple pattern: >>> g = Graph() >>> statementId = BNode() >>> print(len(g)) 0 >>> g.add((statementId, RDF.type, RDF.Statement)) >>> g.add((statementId, RDF.subject, ... URIRef("http://rdflib.net/store/ConjunctiveGraph"))) >>> g.add((statementId, RDF.predicate, RDFS.label)) >>> g.add((statementId, RDF.object, Literal("Conjunctive Graph"))) >>> print(len(g)) 4 >>> for s, p, o in g: ... print(type(s)) ... >>> for s, p, o in g.triples((None, RDF.object, None)): ... print(o) ... Conjunctive Graph >>> g.remove((statementId, RDF.type, RDF.Statement)) >>> print(len(g)) 3 ``None`` terms in calls to :meth:`~rdflib.graph.Graph.triples` can be thought of as "open variables". Graph support set-theoretic operators, you can add/subtract graphs, as well as intersection (with multiplication operator g1*g2) and xor (g1 ^ g2). Note that BNode IDs are kept when doing set-theoretic operations, this may or may not be what you want. Two named graphs within the same application probably want share BNode IDs, two graphs with data from different sources probably not. If your BNode IDs are all generated by RDFLib they are UUIDs and unique. >>> g1 = Graph() >>> g2 = Graph() >>> u = URIRef("http://example.com/foo") >>> g1.add([u, RDFS.label, Literal("foo")]) >>> g1.add([u, RDFS.label, Literal("bar")]) >>> g2.add([u, RDFS.label, Literal("foo")]) >>> g2.add([u, RDFS.label, Literal("bing")]) >>> len(g1 + g2) # adds bing as label 3 >>> len(g1 - g2) # removes foo 1 >>> len(g1 * g2) # only foo 1 >>> g1 += g2 # now g1 contains everything Graph Aggregation - ConjunctiveGraphs and ReadOnlyGraphAggregate within the same store: >>> store = plugin.get("IOMemory", Store)() >>> g1 = Graph(store) >>> g2 = Graph(store) >>> g3 = Graph(store) >>> stmt1 = BNode() >>> stmt2 = BNode() >>> stmt3 = BNode() >>> g1.add((stmt1, RDF.type, RDF.Statement)) >>> g1.add((stmt1, RDF.subject, ... URIRef('http://rdflib.net/store/ConjunctiveGraph'))) >>> g1.add((stmt1, RDF.predicate, RDFS.label)) >>> g1.add((stmt1, RDF.object, Literal('Conjunctive Graph'))) >>> g2.add((stmt2, RDF.type, RDF.Statement)) >>> g2.add((stmt2, RDF.subject, ... URIRef('http://rdflib.net/store/ConjunctiveGraph'))) >>> g2.add((stmt2, RDF.predicate, RDF.type)) >>> g2.add((stmt2, RDF.object, RDFS.Class)) >>> g3.add((stmt3, RDF.type, RDF.Statement)) >>> g3.add((stmt3, RDF.subject, ... URIRef('http://rdflib.net/store/ConjunctiveGraph'))) >>> g3.add((stmt3, RDF.predicate, RDFS.comment)) >>> g3.add((stmt3, RDF.object, Literal( ... 'The top-level aggregate graph - The sum ' + ... 'of all named graphs within a Store'))) >>> len(list(ConjunctiveGraph(store).subjects(RDF.type, RDF.Statement))) 3 >>> len(list(ReadOnlyGraphAggregate([g1,g2]).subjects( ... RDF.type, RDF.Statement))) 2 ConjunctiveGraphs have a :meth:`~rdflib.graph.ConjunctiveGraph.quads` method which returns quads instead of triples, where the fourth item is the Graph (or subclass thereof) instance in which the triple was asserted: >>> uniqueGraphNames = set( ... [graph.identifier for s, p, o, graph in ConjunctiveGraph(store ... ).quads((None, RDF.predicate, None))]) >>> len(uniqueGraphNames) 3 >>> unionGraph = ReadOnlyGraphAggregate([g1, g2]) >>> uniqueGraphNames = set( ... [graph.identifier for s, p, o, graph in unionGraph.quads( ... (None, RDF.predicate, None))]) >>> len(uniqueGraphNames) 2 Parsing N3 from a string >>> g2 = Graph() >>> src = ''' ... @prefix rdf: . ... @prefix rdfs: . ... [ a rdf:Statement ; ... rdf:subject ; ... rdf:predicate rdfs:label; ... rdf:object "Conjunctive Graph" ] . ... ''' >>> g2 = g2.parse(data=src, format="n3") >>> print(len(g2)) 4 Using Namespace class: >>> RDFLib = Namespace("http://rdflib.net/") >>> RDFLib.ConjunctiveGraph rdflib.term.URIRef('http://rdflib.net/ConjunctiveGraph') >>> RDFLib["Graph"] rdflib.term.URIRef('http://rdflib.net/Graph') N)RDFRDFSSKOS)plugin exceptionsquery)NodeURIRefGenid)BNode)Path)Store) Serializer)Parser)create_input_source)NamespaceManager)Resource) Collection)BytesIO)b)urlparseGraphConjunctiveGraph QuotedGraphSeqModificationExceptionDatasetUnSupportedAggregateOperationReadOnlyGraphAggregatecseZdZdZdfdd ZddZeeZdd ZeeZ d d Z d d Z ee e ddZ ddZ ddZddZddZddZddZdddZddd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#d?d@Z$dAdBZ%dCdDZ&dEdFZ'dGdHZ(dIdJZ)e&Z*e'Z+dKdLZ,ddMdNZ-ddOdPZ.ddQdRZ/ddSdTZ0ddUdVZ1ddWdXZ2ddYdZZ3de4j5ddd[fd\d]Z5dd_d`Z6dde7j8e9j6ffdadbZ:ddcddZ;dedfZddkdlZ?dmdnZ@dodpZAddqdrZBddsdtZCdudvZDddxdyZEdd{d|ZFdd}d~ZGdddZHdddZIdddZJddZKddZLddZMddZNddZOddZPddZQddZRdddZSdddZTZUS)rawAn RDF Graph The constructor accepts one argument, the "store" that will be used to store the graph data (see the "store" package for stores currently shipped with rdflib). Stores can be context-aware or unaware. Unaware stores take up (some) less space but cannot support features that require context, such as true merging/demerging of sub-graphs and provenance. The Graph constructor can take an identifier which identifies the Graph by name. If none is given, the graph is assigned a BNode for its identifier. For more on named graphs, see: http://www.w3.org/2004/03/trix/ defaultNcsztt|j||_|pt|_t|jts8t|j|_t|t sXt j |t |_ }n||_ ||_ d|_d|_d|_dS)NF)superr__init__baser_Graph__identifier isinstancer rrr get _Graph__store_Graph__namespace_manager context_awareZ formula_aware default_union)selfstore identifiernamespace_managerr') __class__./tmp/pip-build-7vycvbft/rdflib/rdflib/graph.pyr&(s    zGraph.__init__cCs|jS)N)r+)r/r4r4r5Z __get_store:szGraph.__get_storecCs|jS)N)r()r/r4r4r5Z__get_identifier?szGraph.__get_identifiercCs|jdkrt||_|jS)N)r,r)r/r4r4r5_get_namespace_managerDs  zGraph._get_namespace_managercCs ||_dS)N)r,)r/nmr4r4r5_set_namespace_managerIszGraph._set_namespace_managerzthis graph's namespace-manager)doccCsd|jt|fS)Nz)r1type)r/r4r4r5__repr__RszGraph.__repr__cCs6t|jtr$d|jj|jjjfSd|jjjSdS)Nz%s a rdfg:Graph;rdflib:storage z![a rdflib:Store;rdfs:label '%s'].z[a rdfg:Graph;rdflib:storage z"[a rdflib:Store;rdfs:label '%s']].z@%s a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label '%s'].z?[a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label '%s']].)r)r1rn3r0r3__name__)r/r4r4r5__str__Us  z Graph.__str__cCs|S)Nr4)r/r4r4r5toPython_szGraph.toPythoncCs|jj|dS)zs   zGraph.addN..N)r+addN)r/quadsr4)r/r5rSs z Graph.addNcCs|jj||ddS)zRemove a triple from the graph If the triple does not provide a context attribute, removes the triple from all contexts. )contextN)r+remove)r/rKr4r4r5rVsz Graph.removeccsx|\}}}t|tr>x^|j|||D]\}}|||fVq$Wn6x4|jj|||f|dD]\\}}}}|||fVqVWdS)zGenerator over the triple store Returns triples that match the given triple pattern. If triple pattern does not provide a context, all contexts will be searched. )rUN)r)revalr+triples)r/rKrLrMrNZ_sZ_ocgr4r4r5rXs   &z Graph.triplescCst|tr|j|j|j}}}|dkrH|dkrH|dkrH|j|||fS|dkrb|dkrb|j|S|dkr||dkr||j|S|dkr|dkr|j|S|dkr|j ||S|dkr|j ||S|dkr|j ||S|||f|kSn"t|t t fr|j|StddS)a A graph can be "sliced" as a shortcut for the triples method The python slice syntax is (ab)used for specifying triples. A generator over matches is returned, the returned tuples include only the parts not given >>> import rdflib >>> g = rdflib.Graph() >>> g.add((rdflib.URIRef("urn:bob"), rdflib.RDFS.label, rdflib.Literal("Bob"))) >>> list(g[rdflib.URIRef("urn:bob")]) # all triples about bob [(rdflib.term.URIRef('http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Literal('Bob'))] >>> list(g[:rdflib.RDFS.label]) # all label triples [(rdflib.term.URIRef('urn:bob'), rdflib.term.Literal('Bob'))] >>> list(g[::rdflib.Literal("Bob")]) # all triples with bob as object [(rdflib.term.URIRef('urn:bob'), rdflib.term.URIRef('http://www.w3.org/2000/01/rdf-schema#label'))] Combined with SPARQL paths, more complex queries can be written concisely: Name of all Bobs friends: g[bob : FOAF.knows/FOAF.name ] Some label for Bob: g[bob : DC.title|FOAF.name|RDFS.label] All friends and friends of friends of Bob g[bob : FOAF.knows * "+"] etc. .. versionadded:: 4.0 NzWYou can only index a graph by a single rdflib term or path, or a slice of rdflib terms.)r)slicestartstopsteprXsubject_predicatessubject_objectspredicate_objectssubjects predicatesobjectsrr TypeError)r/itemrLrMrNr4r4r5 __getitem__s*)        zGraph.__getitem__cCs|jj|dS)zReturns the number of triples in the graph If context is specified then the number of triples in the context is returned instead. )rU)r+__len__)r/r4r4r5rgsz Graph.__len__cCs |jdS)z&Iterates over all triples in the storeN)NNN)rX)r/r4r4r5__iter__szGraph.__iter__cCsx|j|D]}dSWdS)z$Support for 'triple in graph' syntaxTF)rX)r/rKr4r4r5 __contains__szGraph.__contains__cCs t|jS)N)hashr1)r/r4r4r5__hash__szGraph.__hash__cCs6|dkr dSt|tr.|j|jk|j|jkSdSdS)N)r)rr1)r/otherr4r4r5__cmp__s   z Graph.__cmp__cCst|to|j|jkS)N)r)rr1)r/rnr4r4r5__eq__sz Graph.__eq__cCs|dkpt|to|j|jkS)N)r)rr1)r/rnr4r4r5__lt__sz Graph.__lt__cCs||kp||kS)Nr4)r/rnr4r4r5__le__sz Graph.__le__cCst|tr|j|jkp|dk S)N)r)rr1)r/rnr4r4r5__gt__sz Graph.__gt__cCs||kp||kS)Nr4)r/rnr4r4r5__ge__!sz Graph.__ge__csjfdd|DS)zNAdd all triples in Graph other to Graph. BNode IDs are not changed.c3s |]\}}}|||fVqdS)Nr4)rPrLrMrN)r/r4r5rR'sz!Graph.__iadd__..)rS)r/rnr4)r/r5__iadd__$szGraph.__iadd__cCsx|D]}|j|qW|S)zUSubtract all triples in Graph other from Graph. BNode IDs are not changed.)rV)r/rnrKr4r4r5__isub__*s zGraph.__isub__cCspt}x4tt|jt|jD]\}}|j||q$Wx|D]}|j|qBWx|D]}|j|qZW|S)z9Set-theoretic union BNode IDs are not changed.)rsetlist namespacesbindrJ)r/rnretvalprefixurixyr4r4r5__add__1s&  z Graph.__add__cCs*t}x|D]}||kr |j|q W|S)zASet-theoretic intersection. BNode IDs are not changed.)rrJ)r/rnr{r~r4r4r5__mul__=s  z Graph.__mul__cCs*t}x|D]}||kr |j|q W|S)z?Set-theoretic difference. BNode IDs are not changed.)rrJ)r/rnr{r~r4r4r5__sub__Fs  z Graph.__sub__cCs||||S)z8Set-theoretic XOR. BNode IDs are not changed.r4)r/rnr4r4r5__xor__Osz Graph.__xor__cCsN|\}}}|dk std|dk s*td|j||df|j|||fdS)zConvenience method to update the value of object Remove any existing triples for subject and predicate before adding (subject, predicate, object). Nz>s can't be None in .set([s,p,o]), as it would remove (*, p, *)z>p can't be None in .set([s,p,o]), as it would remove (s, *, *))rIrVrJ)r/rKsubject predicateobject_r4r4r5rwYs   z Graph.setccs*x$|jd||fD]\}}}|VqWdS)z;A generator of subjects with the given predicate and objectN)rX)r/robjectrLrMrNr4r4r5raiszGraph.subjectsccs*x$|j|d|fD]\}}}|VqWdS)z;A generator of predicates with the given subject and objectN)rX)r/rrrLrMrNr4r4r5rbnszGraph.predicatesccs*x$|j||dfD]\}}}|VqWdS)z;A generator of objects with the given subject and predicateN)rX)r/rrrLrMrNr4r4r5rcssz Graph.objectsccs.x(|jdd|fD]\}}}||fVqWdS)z?A generator of (subject, predicate) tuples for the given objectN)rX)r/rrLrMrNr4r4r5r^xszGraph.subject_predicatesccs.x(|jd|dfD]\}}}||fVqWdS)z?A generator of (subject, object) tuples for the given predicateN)rX)r/rrLrMrNr4r4r5r_}szGraph.subject_objectsccs.x(|j|ddfD]\}}}||fVqWdS)z?A generator of (predicate, object) tuples for the given subjectN)rX)r/rrLrMrNr4r4r5r`szGraph.predicate_objectsc csD|\}}}x4|jj|||f|dD]\\}}}} |||fVq"WdS)N)rU)r0triples_choices) r/rKrUrrrrLrMrNrYr4r4r5rs zGraph.triples_choicesTcCs(|}|dkr|dks4|dkr$|dks4|dkr8|dkr8dS|dkrL|j||}|dkr`|j||}|dkrt|j||}y t|}Wntk r|}YnX|dkr$yht|d|||f}|jj|||fd} x.| D]&\\} } } } |d| | | t| f7}qWtj |Wntk r"YnX|S)aGet a value for a pair of two criteria Exactly one of subject, predicate, object must be None. Useful if one knows that there may only be one value. It is one of those situations that occur a lot, hence this 'macro' like utility Parameters: subject, predicate, object -- exactly one must be None default -- value to be returned if no values found any -- if True, return any value in the case there is more than one, else, raise UniquenessError NFzYWhile trying to find a value for (%s, %s, %s) the following multiple values where found: z(%s, %s, %s) (contexts: %s) ) rcrarbnext StopIterationr0rXrxr ZUniquenessError)r/rrrr$anyr{valuesmsgrXrLrMrNcontextsr4r4r5values>       z Graph.valuecCs |dkr |S|j|tj|ddS)z{Query for the RDFS.label of the subject Return default if no label exists or any label if multiple exist. NT)r$r)rrlabel)r/rr$r4r4r5rsz Graph.labelcs|dkr g}dk r4dkr&dd}q<fdd}ndd}xD|D]<tt||j|}t|dkrlqBqBfdd |DSqBW|S) a  Find the preferred label for subject. By default prefers skos:prefLabels over rdfs:labels. In case at least one prefLabel is found returns those, else returns labels. In case a language string (e.g., "en", "de" or even "" for no lang-tagged literals) is given, only such labels will be considered. Return a list of (labelProp, label) pairs, where labelProp is either skos:prefLabel or rdfs:label. >>> from rdflib import ConjunctiveGraph, URIRef, RDFS, Literal >>> from rdflib.namespace import SKOS >>> from pprint import pprint >>> g = ConjunctiveGraph() >>> u = URIRef("http://example.com/foo") >>> g.add([u, RDFS.label, Literal("foo")]) >>> g.add([u, RDFS.label, Literal("bar")]) >>> pprint(sorted(g.preferredLabel(u))) [(rdflib.term.URIRef('http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Literal('bar')), (rdflib.term.URIRef('http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Literal('foo'))] >>> g.add([u, SKOS.prefLabel, Literal("bla")]) >>> pprint(g.preferredLabel(u)) [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('bla'))] >>> g.add([u, SKOS.prefLabel, Literal("blubb", lang="en")]) >>> sorted(g.preferredLabel(u)) #doctest: +NORMALIZE_WHITESPACE [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('bla')), (rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('blubb', lang='en'))] >>> g.preferredLabel(u, lang="") #doctest: +NORMALIZE_WHITESPACE [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('bla'))] >>> pprint(g.preferredLabel(u, lang="en")) [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('blubb', lang='en'))] NrcSs |jdkS)N)language)lr4r4r5 langfilter sz(Graph.preferredLabel..langfiltercs |jkS)N)r)r)langr4r5rscSsdS)NTr4)rr4r4r5rsrcsg|] }|fqSr4r4)rPr) labelPropr4r5 sz(Graph.preferredLabel..)rxfilterrclen)r/rrr$ZlabelPropertiesrlabelsr4)rrr5preferredLabels0   zGraph.preferredLabelcCs |dkr |S|j|tj|ddS)z_Query for the RDFS.comment of the subject Return default if no comment exists NT)r$r)rrcomment)r/rr$r4r4r5rsz Graph.commentccs\t|g}xL|rV|j|tj}|dk r,|V|j|tj}||krJtd|j|q WdS)zgGenerator over all items in the resource specified by list list is an RDF collection. Nz,List contains a recursive rdf:rest reference)rwrrfirstrest ValueErrorrJ)r/rxchainrer4r4r5items's z Graph.itemsccs^|dkri}n ||krdSd||<x6|||D](}|Vx|j|||D] }|VqHWq.WdS)a~ Generates transitive closure of a user-defined function against the graph >>> from rdflib.collection import Collection >>> g=Graph() >>> a=BNode("foo") >>> b=BNode("bar") >>> c=BNode("baz") >>> g.add((a,RDF.first,RDF.type)) >>> g.add((a,RDF.rest,b)) >>> g.add((b,RDF.first,RDFS.label)) >>> g.add((b,RDF.rest,c)) >>> g.add((c,RDF.first,RDFS.comment)) >>> g.add((c,RDF.rest,RDF.nil)) >>> def topList(node,g): ... for s in g.subjects(RDF.rest, node): ... yield s >>> def reverseList(node,g): ... for f in g.objects(node, RDF.first): ... print(f) ... for s in g.subjects(RDF.rest, node): ... yield s >>> [rt for rt in g.transitiveClosure( ... topList,RDF.nil)] # doctest: +NORMALIZE_WHITESPACE [rdflib.term.BNode('baz'), rdflib.term.BNode('bar'), rdflib.term.BNode('foo')] >>> [rt for rt in g.transitiveClosure( ... reverseList,RDF.nil)] # doctest: +NORMALIZE_WHITESPACE http://www.w3.org/2000/01/rdf-schema#comment http://www.w3.org/2000/01/rdf-schema#label http://www.w3.org/1999/02/22-rdf-syntax-ns#type [rdflib.term.BNode('baz'), rdflib.term.BNode('bar'), rdflib.term.BNode('foo')] Nrl)transitiveClosure)r/funcargseenrtZrt_2r4r4r5r6s)zGraph.transitiveClosureccs^|dkr i}||krdSd||<|Vx2|j||D]"}x|j|||D] }|VqHWq4WdS)zTransitively generate objects for the ``property`` relationship Generated objects belong to the depth first transitive closure of the ``property`` relationship starting at ``subject``. Nrl)rctransitive_objects)r/rpropertyrememberrrNr4r4r5riszGraph.transitive_objectsccs^|dkr i}||krdSd||<|Vx2|j||D]"}x|j|||D] }|VqHWq4WdS)zTransitively generate objects for the ``property`` relationship Generated objects belong to the depth first transitive closure of the ``property`` relationship starting at ``subject``. Nrl)ratransitive_subjects)r/rrrrrLr4r4r5ryszGraph.transitive_subjectscCs$|tjtjf|krt||SdSdS)ziCheck if subject is an rdf:Seq If yes, it returns a Seq class instance, None otherwise. N)rr:r)r/rr4r4r5seqs z Graph.seqcCs |jj|S)N)r2qname)r/r}r4r4r5rsz Graph.qnamecCs|jj||S)N)r2 compute_qname)r/r}generater4r4r5rszGraph.compute_qnamecCs|jj||||dS)a6Bind prefix to namespace If override is True will bind namespace to given prefix even if namespace was already bound to a different prefix. if replace, replace any existing prefix with the new namespace for example: graph.bind("foaf", "http://xmlns.com/foaf/0.1/") )overridereplace)r2rz)r/r| namespacerrr4r4r5rzs z Graph.bindccs&x |jjD]\}}||fVq WdS)z/Generator over all the prefix, namespace tuplesN)r2ry)r/r|rr4r4r5ryszGraph.namespacesrlcCs|jj||S)z5Turn uri into an absolute URI if it's not one already)r2 absolutize)r/r}defragr4r4r5rszGraph.absolutizexmlcKs |dkr|j}tj|t|}|dkrLt}|j|f||d||jSt|drt|}|j|f||d|n|}t|\} } } } } }| dkrt d dSt j \}}t j |d}|j|f||d||jttdrtj|| ntj|| t j|dS) aHSerialize the Graph to destination If destination is None serialize method returns the serialization as a string. Format defaults to xml (AKA rdf/xml). Format support can be extended with plugins, but "xml", "n3", "turtle", "nt", "pretty-xml", "trix", "trig" and "nquads" are built in. N)r'encodingwriterzWARNING: not saving as locationzis not a local file referencewbmovez>> my_data = ''' ... ... ... Example ... This is really just an example. ... ... ... ''' >>> import tempfile >>> fd, file_name = tempfile.mkstemp() >>> f = os.fdopen(fd, "w") >>> dummy = f.write(my_data) # Returns num bytes written on py3 >>> f.close() >>> g = Graph() >>> result = g.parse(data=my_data, format="application/rdf+xml") >>> len(g) 2 >>> g = Graph() >>> result = g.parse(location=file_name, format="application/rdf+xml") >>> len(g) 2 >>> g = Graph() >>> with open(file_name, "r") as f: ... result = g.parse(f, format="application/rdf+xml") >>> len(g) 2 >>> os.remove(file_name) )sourcepublicIDrfiledatarNzapplication/rdf+xml)r content_typer r*rparseZ auto_closerG) r/rrrrrrrparserr4r4r5rs"K z Graph.parsecCs|j|||dS)N)r)r/rrrr4r4r5load<sz Graph.loadsparqlc Ks|pi}|pt|j}t|jdr`|r`y"|jj||||jr@dpD|jf|Stk r^YnXt|tj szt j |tj }t|tj st j |tj |}||j|||f|S)au Query this graph. A type of 'prepared queries' can be realised by providing initial variable bindings with initBindings Initial namespaces are used to resolve prefixes used in the query, if none are given, the namespaces from the graph's namespace manager are used. :returntype: rdflib.query.QueryResult r __UNION__) dictryrr0r r.r1NotImplementedErrorr)ZResultr r*Z Processor)r/Z query_object processorresultinitNs initBindingsuse_store_providedkwargsr4r4r5r ?s"  z Graph.queryc Ks|pi}|pt|j}t|jdr`|r`y"|jj||||jr@dpD|jf|Stk r^YnXt|t j s~t j |t j |}|j|||f|S)z.Update this graph with the given update query.updater) rryrr0rr.r1rr)r ZUpdateProcessorr r*)r/Z update_objectrrrrrr4r4r5rms  z Graph.updatecCsd|jjS)z%return an n3 identifier for the Graphz[%s])r1r<)r/r4r4r5r<szGraph.n3cCst|j|jffS)N)rr0r1)r/r4r4r5 __reduce__szGraph.__reduce__cCst|t|krdSx<|D]4\}}}t|t rt|t r|||f|krdSqWx<|D]4\}}}t|t rXt|t rX|||f|krXdSqXWdS)z does a very basic check if these graphs are the same If no BNodes are involved, this is accurate. See rdflib.compare for a correct implementation of isomorphism checks FT)rr)r)r/rnrLrMrNr4r4r5 isomorphicszGraph.isomorphiccCst|j}g}|sdS|tjt|g}x|r|j}||krL|j|x.|j|dD]}||krZ||krZ|j|qZWx.|j|dD]}||kr||kr|j|qWq.Wt|t|krdSdSdS)aCheck if the Graph is connected The Graph is considered undirectional. Performs a search on the Graph, starting from a random node. Then iteratively goes depth-first through the triplets where the node is subject and object. Return True if all nodes have been visited and False if it cannot continue and there are still unvisited nodes left. F)r)rTN) rx all_nodesrandom randrangerpopappendrcra)r/rZ discoveredZvisitingr~Znew_xr4r4r5 connecteds$  zGraph.connectedcCst|j}|j|j|S)N)rwrcrra)r/resr4r4r5rs zGraph.all_nodescCs t||S)aCreate a new ``Collection`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> collection = graph.collection(uri) >>> assert isinstance(collection, Collection) >>> assert collection.uri is uri >>> assert collection.graph is graph >>> collection += [ Literal(1), Literal(2) ] )r)r/r1r4r4r5 collectionszGraph.collectioncCst|tst|}t||S)aCreate a new ``Resource`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> resource = graph.resource(uri) >>> assert isinstance(resource, Resource) >>> assert resource.identifier is uri >>> assert resource.graph is graph )r)r rr)r/r1r4r4r5resources zGraph.resourcecCs&x |jdD]}|j||q WdS)N)NNN)rXrJ)r/targetrtr4r4r5_process_skolem_tuplesszGraph._process_skolem_tuplescshfddfdd}|dkr*tn|}dkrD|j||n ttrd|j|fdd|S)Ncs@|\}}}||kr |jd}||kr6|jd}|||fS)N) authoritybasepath) skolemize)bnoderrLrMrN)rrr4r5 do_skolemizes  z%Graph.skolemize..do_skolemizecsD|\}}}t|tr"|jd}t|tr:|jd}|||fS)N)rr)r)rr)rrLrMrN)rrr4r5 do_skolemize2s    z&Graph.skolemize..do_skolemize2cs |S)Nr4)r)rrr4r5sz!Graph.skolemize..)rrr)r)r/ new_graphrrrrr{r4)rrrrr5rs zGraph.skolemizecs\dddd}|dkrtn|}dkr8|j||n ttrX|j|fdd|S)NcSs4|\}}}||kr|j}||kr*|j}|||fS)N) de_skolemize)urirefrrLrMrNr4r4r5do_de_skolemizes  z+Graph.de_skolemize..do_de_skolemizecSs8|\}}}t|tr|j}t|tr.|j}|||fS)N)r)rr)rrLrMrNr4r4r5do_de_skolemize2!s    z,Graph.de_skolemize..do_de_skolemize2cs |S)Nr4)r)rrr4r5r.sz$Graph.de_skolemize..)rrr)r)r/rrrr{r4)rrr5rs zGraph.de_skolemize)r$NNN)F)F)NN)NN)NN)N)N)N)N)r)r)N)N)N)T)TF)rl)NrNN)NNNNNN)Nr)rrNNT)rNNT)NNNN)NN)Vr= __module__ __qualname____doc__r&Z_Graph__get_storerr0Z_Graph__get_identifierr1r6r8r2r;r>r?r@rBrCrDrGrJrSrVrXrfrgrhrirkrorprqrrrsrtrurvrrrr__or____and__rwrarbrcr^r_r`rrrrr Z prefLabelrrrrrrrrrrrzryrrrrr rr<rrrrrrrrr __classcell__r4r4)r3r5rs    G           : G  3       + Z  * % cseZdZdZd*fdd ZddZd+d d Zd d Zd dZddZ ddZ ddZ d,ddZ d-ddZ d.ddZddZd/ddZd0dd Zd!d"Zd1d#d$Zd2d&d'Zd(d)ZZS)3raA ConjunctiveGraph is an (unnamed) aggregation of all the named graphs in a store. It has a ``default`` graph, whose name is associated with the graph throughout its life. :meth:`__init__` can take an identifier to use as the name of this default graph or it will assign a BNode. All methods that add triples work against this default graph. All queries are carried out against the union of all graphs. r$NcsLtt|j||d|jjs$tdd|_d|_t|j|p>t|d|_ dS)N)r1z9ConjunctiveGraph must be backed by a context aware store.T)r0r1r') r%rr&r0r-rIr.rrdefault_context)r/r0r1default_graph_base)r3r4r5r&As zConjunctiveGraph.__init__cCsd}||jjjS)NzK[a rdflib:ConjunctiveGraph;rdflib:storage [a rdflib:Store;rdfs:label '%s']])r0r3r=)r/patternr4r4r5r>LszConjunctiveGraph.__str__FcCsr|dkrddd|r|jndfSt|dkrD|r4|jnd}|\}}}n"t|dkrf|\}}}}|j|}||||fS)z_ helper method for having methods that support either triples or quads N)rr_graph)r/triple_or_quadr$rQrLrMrNr4r4r5_spocSs     zConjunctiveGraph._spoccCs6|j|\}}}}x|j|||f|dD]}dSWdS)z)Support for 'triple/quad in graph' syntax)rUTF)r rX)r/rrLrMrNrQrr4r4r5ribszConjunctiveGraph.__contains__cCs>|j|dd\}}}}t||||jj|||f|dddS)zu Add a triple or quad to the store. if a triple is given it is added to the default context T)r$F)rUrHN)r rOr0rJ)r/rrLrMrNrQr4r4r5rJis zConjunctiveGraph.addcCs(|dkr dSt|ts |j|S|SdS)N)r)r get_context)r/rQr4r4r5rvs   zConjunctiveGraph._graphcsjjfdd|DdS)z&Add a sequence of triples with contextc3s4|],\}}}}t|||r|||j|fVqdS)N)rOr)rPrLrMrNrQ)r/r4r5rRsz(ConjunctiveGraph.addN..N)r0rS)r/rTr4)r/r5rS~szConjunctiveGraph.addNcCs,|j|\}}}}|jj|||f|ddS)z Removes a triple or quads if a triple is given it is removed from all contexts a quad is removed from the given context only )rUN)r r0rV)r/rrLrMrNrQr4r4r5rVs zConjunctiveGraph.removeccs|j|\}}}}|j|p|}|jr6||jkrDd}n|dkrD|j}t|tr|dkrZ|}x^|j|||D]\}}|||fVqjWn6x4|jj|||f|dD]\\}}}}|||fVqWdS)a Iterate over all the triples in the entire conjunctive graph For legacy reasons, this can take the context to query either as a fourth element of the quad, or as the explicit context keyword parameter. The kw param takes precedence. N)rU) r rr.rr)rrWr0rX)r/rrUrLrMrNrQrYr4r4r5rXs   &zConjunctiveGraph.triplesccs\|j|\}}}}xD|jj|||f|dD]*\\}}}}x|D]}||||fVq>Wq*WdS)z:Iterate over all the quads in the entire conjunctive graph)rUN)r r0rX)r/rrLrMrNrQrYctxr4r4r5rTs& zConjunctiveGraph.quadsc csd|\}}}|dkr |js*|j}n |j|}x4|jj|||f|dD]\\}}}} |||fVqBWdS)z Parse source adding the resulting triples to its own context (sub graph of this graph). See :meth:`rdflib.graph.Graph.parse` for documentation on arguments. :Returns: The graph into which the source was parsed. In the case of n3 it returns the root context. )rrrrrr)r0r1N)rr)NNN) r getPublicIdr)r rrr0rVr) r/rrrrrrrZg_idrUr4r4r5rs  zConjunctiveGraph.parsecCst|j|jffS)N)rr0r1)r/r4r4r5rszConjunctiveGraph.__reduce__)r$NN)F)N)N)N)N)FN)N)NNrNNN)r=rrrr&r>r rirJrrSrVrXrTrrgrr rrrrrr4r4)r3r5r3s0          !zurn:x-rdflib:defaultcsleZdZdZdfdd ZddZdd d Zdd d ZddZddZ dfdd Z e Z fddZ Z S)r!aV RDF 1.1 Dataset. Small extension to the Conjunctive Graph: - the primary term is graphs in the datasets and not contexts with quads, so there is a separate method to set/retrieve a graph in a dataset and operate with graphs - graphs cannot be identified with blank nodes - added a method to directly add a single quad Examples of usage: >>> # Create a new Dataset >>> ds = Dataset() >>> # simple triples goes to default graph >>> ds.add((URIRef("http://example.org/a"), ... URIRef("http://www.example.org/b"), ... Literal("foo"))) >>> >>> # Create a graph in the dataset, if the graph name has already been >>> # used, the corresponding graph will be returned >>> # (ie, the Dataset keeps track of the constituent graphs) >>> g = ds.graph(URIRef("http://www.example.com/gr")) >>> >>> # add triples to the new graph as usual >>> g.add( ... (URIRef("http://example.org/x"), ... URIRef("http://example.org/y"), ... Literal("bar")) ) >>> # alternatively: add a quad to the dataset -> goes to the graph >>> ds.add( ... (URIRef("http://example.org/x"), ... URIRef("http://example.org/z"), ... Literal("foo-bar"),g) ) >>> >>> # querying triples return them all regardless of the graph >>> for t in ds.triples((None,None,None)): # doctest: +SKIP ... print(t) # doctest: +NORMALIZE_WHITESPACE (rdflib.term.URIRef("http://example.org/a"), rdflib.term.URIRef("http://www.example.org/b"), rdflib.term.Literal("foo")) (rdflib.term.URIRef("http://example.org/x"), rdflib.term.URIRef("http://example.org/z"), rdflib.term.Literal("foo-bar")) (rdflib.term.URIRef("http://example.org/x"), rdflib.term.URIRef("http://example.org/y"), rdflib.term.Literal("bar")) >>> >>> # querying quads return quads; the fourth argument can be unrestricted >>> # or restricted to a graph >>> for q in ds.quads((None, None, None, None)): # doctest: +SKIP ... print(q) # doctest: +NORMALIZE_WHITESPACE (rdflib.term.URIRef("http://example.org/a"), rdflib.term.URIRef("http://www.example.org/b"), rdflib.term.Literal("foo"), None) (rdflib.term.URIRef("http://example.org/x"), rdflib.term.URIRef("http://example.org/y"), rdflib.term.Literal("bar"), rdflib.term.URIRef("http://www.example.com/gr")) (rdflib.term.URIRef("http://example.org/x"), rdflib.term.URIRef("http://example.org/z"), rdflib.term.Literal("foo-bar"), rdflib.term.URIRef("http://www.example.com/gr")) >>> >>> for q in ds.quads((None,None,None,g)): # doctest: +SKIP ... print(q) # doctest: +NORMALIZE_WHITESPACE (rdflib.term.URIRef("http://example.org/x"), rdflib.term.URIRef("http://example.org/y"), rdflib.term.Literal("bar"), rdflib.term.URIRef("http://www.example.com/gr")) (rdflib.term.URIRef("http://example.org/x"), rdflib.term.URIRef("http://example.org/z"), rdflib.term.Literal("foo-bar"), rdflib.term.URIRef("http://www.example.com/gr")) >>> # Note that in the call above - >>> # ds.quads((None,None,None,"http://www.example.com/gr")) >>> # would have been accepted, too >>> >>> # graph names in the dataset can be queried: >>> for c in ds.graphs(): # doctest: +SKIP ... print(c) # doctest: DEFAULT http://www.example.com/gr >>> # A graph can be created without specifying a name; a skolemized genid >>> # is created on the fly >>> h = ds.graph() >>> for c in ds.graphs(): # doctest: +SKIP ... print(c) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS DEFAULT http://rdlib.net/.well-known/genid/rdflib/N... http://www.example.com/gr >>> # Note that the Dataset.graphs() call returns names of empty graphs, >>> # too. This can be restricted: >>> for c in ds.graphs(empty=False): # doctest: +SKIP ... print(c) # doctest: +NORMALIZE_WHITESPACE DEFAULT http://www.example.com/gr >>> >>> # a graph can also be removed from a dataset via ds.remove_graph(g) .. versionadded:: 4.0 r$FNcs@tt|j|dd|jjs$tdt|jt|d|_||_ dS)N)r0r1z.DataSet must be backed by a graph-aware store!)r0r1r') r%r!r&r0Z graph_aware ExceptionrDATASET_DEFAULT_GRAPH_IDrr.)r/r0r.r)r3r4r5r&~s zDataset.__init__cCsd}||jjjS)NzB[a rdflib:Dataset;rdflib:storage [a rdflib:Store;rdfs:label '%s']])r0r3r=)r/rr4r4r5r>szDataset.__str__cCsR|dkr2ddlm}|jdd|ddtj}|j|}||_|jj||S)Nr)rdflib_skolem_genidZgenidzhttp://rdflib.netF)r) rdflib.termrrzrrrr'r0 add_graph)r/r1r'rgr4r4r5graphs    z Dataset.graphrc Ks(tj|||||||f|}|j||S)N)rrr) r/rrrrrrrrQr4r4r5rs  z Dataset.parsecCs |j|S)zalias of graph for consistency)r)r/rr4r4r5rszDataset.add_graphcCsDt|ts|j|}|jj||dks2||jkr@|jj|jdS)N)r)rr r0 remove_graphrr)r/rr4r4r5rs    zDataset.remove_graphc#sFd}x,tt|j|D]}||jtkO}|VqW|sB|jtVdS)NF)r%r!rr1rr)r/rKr$rQ)r3r4r5rs  zDataset.contextsc#sRxLtt|j|D]8\}}}}|j|jkr:|||dfVq||||jfVqWdS)N)r%r!rTr1r)r/ZquadrLrMrNrQ)r3r4r5rTs z Dataset.quads)r$FN)NN)NNrNNN)N)r=rrrr&r>rrrrrgraphsrTrr4r4)r3r5r!se    csHeZdZdZfddZddZddZdd Zd d Zd d Z Z S)ra Quoted Graphs are intended to implement Notation 3 formulae. They are associated with a required identifier that the N3 parser *must* provide in order to maintain consistent formulae identification for scenarios such as implication and other such processing. cstt|j||dS)N)r%rr&)r/r0r1)r3r4r5r&szQuotedGraph.__init__cCsn|\}}}t|ts"td|ft|ts:td|ft|tsRtd|f|jj|||f|dddS)z!Add a triple with self as contextz!Subject %s must be an rdflib termz#Predicate %s must be an rdflib termz Object %s must be an rdflib termT)rHN)r)r rIr0rJ)r/rKrLrMrNr4r4r5rJs  zQuotedGraph.addcsjjfdd|DdS)z%Add a sequence of triple with contextc3sD|]<\}}}}t|tr|jjkrt|||r||||fVqdS)N)r)rr1rO)rPrLrMrNrQ)r/r4r5rRs   z#QuotedGraph.addN..N)r0rS)r/rTr4)r/r5rSs zQuotedGraph.addNcCsd|jjS)z%Return an n3 identifier for the Graphz{%s})r1r<)r/r4r4r5r<szQuotedGraph.n3cCs$|jj}|jjj}d}|||fS)NzK{this rdflib.identifier %s;rdflib:storage [a rdflib:Store;rdfs:label '%s']})r1r<r0r3r=)r/r1rrr4r4r5r>s  zQuotedGraph.__str__cCst|j|jffS)N)rr0r1)r/r4r4r5rszQuotedGraph.__reduce__) r=rrrr&rJrSr<r>rrr4r4)r3r5rs    c@s8eZdZdZddZddZddZdd Zd d Zd S) ra.Wrapper around an RDF Seq resource It implements a container type in Python with the order of the items returned corresponding to the Seq content. It is based on the natural ordering of the predicate names _1, _2, _3, etc, which is the 'implementation' of a sequence in RDF terms. cCsht}|_tttd}x>|j|D]0\}}|j|r(t|j|d}|j ||fq(W|j dS)aParameters: - graph: the graph containing the Seq - subject: the subject of a Seq. Note that the init does not check whether this is a Seq, this is done in whoever creates this instance! _rN) rx_listrstrrr` startswithintrrsort)r/rrrZLI_INDEXrMrNir4r4r5r&s  z Seq.__init__cCs|S)Nr4)r/r4r4r5r?%sz Seq.toPythonccsx|jD]\}}|VqWdS)z#Generator over the items in the SeqN)r)r/rrer4r4r5rh(sz Seq.__iter__cCs t|jS)zLength of the Seq)rr)r/r4r4r5rg-sz Seq.__len__cCs|jj|\}}|S)z Item given by index from the Seq)rrf)r/indexrer4r4r5rf1szSeq.__getitem__N) r=rrrr&r?rhrgrfr4r4r4r5rs c@seZdZddZddZdS)r cCsdS)Nr4)r/r4r4r5r&8szModificationException.__init__cCsdS)NzZModifications and transactional operations not allowed on ReadOnlyGraphAggregate instancesr4)r/r4r4r5r>;szModificationException.__str__N)r=rrr&r>r4r4r4r5r 7sc@seZdZddZddZdS)r"cCsdS)Nr4)r/r4r4r5r&Csz&UnSupportedAggregateOperation.__init__cCsdS)NzCThis operation is not supported by ReadOnlyGraphAggregate instancesr4)r/r4r4r5r>Fsz%UnSupportedAggregateOperation.__str__N)r=rrr&r>r4r4r4r5r"BscseZdZdZd>fdd ZddZddZd d Zd d Zd?ddZ ddZ ddZ ddZ ddZ ddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd@d)d*Zd+d,ZdAd.d/ZdBd0d1Zd2d3ZdCd5d6ZdDd8d9Zd:d;Zd.z*graphs argument must be a list of Graphs!!) r%r#r&rZ*_ReadOnlyGraphAggregate__namespace_managerr)rxrIr)r/rr0)r3r4r5r&Qs  zReadOnlyGraphAggregate.__init__cCsdt|jS)Nz#)rr)r/r4r4r5r;^szReadOnlyGraphAggregate.__repr__cCs tdS)N)r )r/rAr4r4r5r@aszReadOnlyGraphAggregate.destroycCs tdS)N)r )r/r4r4r5rBeszReadOnlyGraphAggregate.commitcCs tdS)N)r )r/r4r4r5rChszReadOnlyGraphAggregate.rollbackFcCs"x|jD]}|j|||qWdS)N)rrD)r/rArErr4r4r5rDks zReadOnlyGraphAggregate.opencCsx|jD] }|jqWdS)N)rrG)r/rr4r4r5rGps zReadOnlyGraphAggregate.closecCs tdS)N)r )r/rKr4r4r5rJtszReadOnlyGraphAggregate.addcCs tdS)N)r )r/rTr4r4r5rSwszReadOnlyGraphAggregate.addNcCs tdS)N)r )r/rKr4r4r5rVzszReadOnlyGraphAggregate.removec cs~|\}}}xn|jD]d}t|trJxT|j|||D]\}}|||fVq0Wqx*|j|||fD]\}}}|||fVq\WqWdS)N)rr)rrWrX) r/rKrLrMrNrr r rr4r4r5rX}s   zReadOnlyGraphAggregate.triplescCsTd}t|dkr|d}x6|jD],}|dks8|j|jkr |dd|kr dSq WdS)NrrTF)rrr1)r/rrUrr4r4r5ris  z#ReadOnlyGraphAggregate.__contains__c csL|\}}}x<|jD]2}x,|j|||fD]\}}}||||fVq(WqWdS)z8Iterate over all the quads in the entire aggregate graphN)rrX) r/rKrLrMrNrr r rr4r4r5rTs  zReadOnlyGraphAggregate.quadscCstdd|jDS)Ncss|]}t|VqdS)N)r)rPrr4r4r5rRsz1ReadOnlyGraphAggregate.__len__..)sumr)r/r4r4r5rgszReadOnlyGraphAggregate.__len__cCs tdS)N)r")r/r4r4r5rkszReadOnlyGraphAggregate.__hash__cCsD|dkr dSt|trdSt|tr<|j|jk|j|jkSdSdS)Nrlrmrmrm)r)rr#r)r/rnr4r4r5ros  zReadOnlyGraphAggregate.__cmp__cCs tdS)N)r )r/rnr4r4r5ruszReadOnlyGraphAggregate.__iadd__cCs tdS)N)r )r/rnr4r4r5rvszReadOnlyGraphAggregate.__isub__Nc csN|\}}}x>|jD]4}|j|||f}x|D]\}} } || | fVq,WqWdS)N)rr) r/rKrUrrrrchoicesrLrMrNr4r4r5rs   z&ReadOnlyGraphAggregate.triples_choicescCs&t|dr|jr|jj|StdS)Nr2)rr2rr")r/r}r4r4r5rs zReadOnlyGraphAggregate.qnameTcCs(t|dr|jr|jj||StdS)Nr2)rr2rr")r/r}rr4r4r5rsz$ReadOnlyGraphAggregate.compute_qnamecCs tdS)N)r")r/r|rrr4r4r5rzszReadOnlyGraphAggregate.bindccsbt|dr.xR|jjD]\}}||fVqWn0x.|jD]$}x|jD]\}}||fVqDWq6WdS)Nr2)rr2ryr)r/r|rrr4r4r5rys   z!ReadOnlyGraphAggregate.namespacesrlcCs tdS)N)r")r/r}rr4r4r5rsz!ReadOnlyGraphAggregate.absolutizercKs tdS)N)r )r/rrrrr4r4r5rszReadOnlyGraphAggregate.parsecCs tdS)N)r")r/r4r4r5r<szReadOnlyGraphAggregate.n3cCs tdS)N)r")r/r4r4r5rsz!ReadOnlyGraphAggregate.__reduce__)r$)F)N)T)T)rl)Nr) r=rrrr&r;r@rBrCrDrGrJrSrVrXrirTrgrkrorurvrrrrzryrrr<rrr4r4)r3r5r#Js8          cGs*x$|D]}t|tstd|fqWdS)NzTerm %s must be an rdflib termT)r)r rI)Ztermsrr4r4r5rOs rOcCsddl}|jdS)Nr)doctesttestmod)r(r4r4r5testsr*__main__)@ __future__rrrrrrIZrdflib.namespacerrlogging getLoggerr=loggerrrrr Zrdflibr r r r rrrZ rdflib.pathsrZ rdflib.storerZrdflib.serializerrZ rdflib.parserrrrZrdflib.resourcerZrdflib.collectionrrrrsixrrZsix.moves.urllib.parser__all__rrrr!rZtermZ _ORDERINGrrrr r"r#rOr*r4r4r4r5s~     c             &b84 2