01ipSrSSKJr SSKrSSKrSSKrSSKrSSKJr SSK J r J r J r J r JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJr SSK J!r! SSK"J#r# SSK$J%r% SSK&J'r' SSK(J)r) SSK*r+SSK,J-r- SS K"J.r. SS K$J/r/J0r0J1r1 SS K2J3r3J4r4J5r5 SS K6J7r7 SS K8J9r9 SSK:J;r; SSKJ?r?J@r@JArAJBrBJCrCJDrDJErEJFrF \ (aSSKGrHSSK(r+SSKIJJrJJKrK \DrL\DrM\DrN\ArO\SrP\SrQ\SSS\S4rR\SrS\SSS\S4rT\\S\S\S4rU\\S\7\S4rV\\S\S\S\S4rW\\S\7\S\S4rX\SrY\SrZ\\S\\S\S4r[\\S\\S\S\S4r\\Sr]\S\7S4r^\Sr_\\\\L\\M\\N4\\\L\\M\\N4\\\L\\M\\N44r`\"SS S!9ra\"S"S#S!9rb\"S$S%S!9rc\C(de\0(de\ (aSS&KdJere \R"\g5rh/S'Qri\"S(5rj"S)S \D5rk\krl"S*S#\k5rm\F"S+5rn"S,S%\m5ro"S-S.\k5rpS/\+RR\p'"S0S15rs"S2S3\t5ru"S4S5\t5rv"S6S7\m5rw\S=S8j5rx\S>S9j5rxS>S:jrx"S;S<5ryg)?ak$ RDFLib defines the following kinds of Graphs: * [`Graph`][rdflib.graph.Graph] * [`QuotedGraph`][rdflib.graph.QuotedGraph] * [`ConjunctiveGraph`][rdflib.graph.ConjunctiveGraph] * [`Dataset`][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 [`Graph`][rdflib.graph.Graph] ## Conjunctive Graph !!! warning "Deprecation notice" `ConjunctiveGraph` is deprecated, use [`Dataset`][rdflib.graph.Dataset] instead. 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 [`Store`][rdflib.store.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 [`BNode`][rdflib.term.BNode] for an identifier - if one isn't given. See [`ConjunctiveGraph`][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 [`QuotedGraph`][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 [`Dataset`][rdflib.graph.Dataset] ## Working with graphs Instantiating Graphs with default store (Memory) and default identifier (a BNode): ```python >>> g = Graph() >>> g.store.__class__ >>> g.identifier.__class__ ``` Instantiating Graphs with a Memory store and an identifier - : ```python >>> g = Graph('Memory', URIRef("https://rdflib.github.io")) >>> g.identifier rdflib.term.URIRef('https://rdflib.github.io') >>> str(g) # doctest: +NORMALIZE_WHITESPACE " a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'Memory']." ``` Creating a ConjunctiveGraph - The top level container for all named Graphs in a "database": ```python >>> g = ConjunctiveGraph() >>> str(g.default_context) "[a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'Memory']]." ``` Adding / removing reified triples to Graph and iterating over it directly or via triple pattern: ```python >>> g = Graph() >>> statementId = BNode() >>> print(len(g)) 0 >>> g.add((statementId, RDF.type, RDF.Statement)) # doctest: +ELLIPSIS )> >>> g.add((statementId, RDF.subject, ... URIRef("https://rdflib.github.io/store/ConjunctiveGraph"))) # doctest: +ELLIPSIS )> >>> g.add((statementId, RDF.predicate, namespace.RDFS.label)) # doctest: +ELLIPSIS )> >>> g.add((statementId, RDF.object, Literal("Conjunctive Graph"))) # doctest: +ELLIPSIS )> >>> 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)) # doctest: +ELLIPSIS )> >>> print(len(g)) 3 ``` `None` terms in calls to [`triples()`][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. ```python >>> g1 = Graph() >>> g2 = Graph() >>> u = URIRef("http://example.com/foo") >>> g1.add([u, namespace.RDFS.label, Literal("foo")]) # doctest: +ELLIPSIS )> >>> g1.add([u, namespace.RDFS.label, Literal("bar")]) # doctest: +ELLIPSIS )> >>> g2.add([u, namespace.RDFS.label, Literal("foo")]) # doctest: +ELLIPSIS )> >>> g2.add([u, namespace.RDFS.label, Literal("bing")]) # doctest: +ELLIPSIS )> >>> 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: ```python >>> store = plugin.get("Memory", Store)() >>> g1 = Graph(store) >>> g2 = Graph(store) >>> g3 = Graph(store) >>> stmt1 = BNode() >>> stmt2 = BNode() >>> stmt3 = BNode() >>> g1.add((stmt1, RDF.type, RDF.Statement)) # doctest: +ELLIPSIS )> >>> g1.add((stmt1, RDF.subject, ... URIRef('https://rdflib.github.io/store/ConjunctiveGraph'))) # doctest: +ELLIPSIS )> >>> g1.add((stmt1, RDF.predicate, namespace.RDFS.label)) # doctest: +ELLIPSIS )> >>> g1.add((stmt1, RDF.object, Literal('Conjunctive Graph'))) # doctest: +ELLIPSIS )> >>> g2.add((stmt2, RDF.type, RDF.Statement)) # doctest: +ELLIPSIS )> >>> g2.add((stmt2, RDF.subject, ... URIRef('https://rdflib.github.io/store/ConjunctiveGraph'))) # doctest: +ELLIPSIS )> >>> g2.add((stmt2, RDF.predicate, RDF.type)) # doctest: +ELLIPSIS )> >>> g2.add((stmt2, RDF.object, namespace.RDFS.Class)) # doctest: +ELLIPSIS )> >>> g3.add((stmt3, RDF.type, RDF.Statement)) # doctest: +ELLIPSIS )> >>> g3.add((stmt3, RDF.subject, ... URIRef('https://rdflib.github.io/store/ConjunctiveGraph'))) # doctest: +ELLIPSIS )> >>> g3.add((stmt3, RDF.predicate, namespace.RDFS.comment)) # doctest: +ELLIPSIS )> >>> g3.add((stmt3, RDF.object, Literal( ... 'The top-level aggregate graph - The sum ' + ... 'of all named graphs within a Store'))) # doctest: +ELLIPSIS )> >>> len(list(ConjunctiveGraph(store).subjects(RDF.type, RDF.Statement))) 3 >>> len(list(ReadOnlyGraphAggregate([g1,g2]).subjects( ... RDF.type, RDF.Statement))) 2 ``` ConjunctiveGraphs have a [`quads()`][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: ```python >>> 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: ```python >>> 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: ```python >>> RDFLib = Namespace("https://rdflib.github.io/") >>> RDFLib.ConjunctiveGraph rdflib.term.URIRef('https://rdflib.github.io/ConjunctiveGraph') >>> RDFLib["Graph"] rdflib.term.URIRef('https://rdflib.github.io/Graph') ``` ) annotationsN)BytesIO)IO TYPE_CHECKINGAnyBinaryIOCallableDict GeneratorIterableListMappingNoReturnOptionalSetTextIOTupleTypeTypeVarUnioncastoverload)urlparse) url2pathname Collection) ParserError)RDF NamespaceNamespaceManager) InputSourceParsercreate_input_source)Path)Resource) Serializer)Store)BNodeGenidIdentifiedNode IdentifierLiteralNode RDFLibGenidURIRef)QueryUpdate) _SubjectType_PredicateType _ObjectType)r2r3r4 _ContextTyper2r3r4r5) _TripleType_OptionalQuadType_ContextIdentifierType)_TriplePatternType_QuadPatternType)_TriplePathPatternType_QuadPathPatternType)r$r3)_TripleSelectorType_QuadSelectorType)r6_TriplePathType_GraphTGraph)bound_ConjunctiveGraphTConjunctiveGraph _DatasetTDataset)_NamespaceSetString) rArD QuotedGraphSeqModificationExceptionrFUnSupportedAggregateOperationReadOnlyGraphAggregate BatchAddGraphrCr8rEr@r4_OptionalIdentifiedQuadTyper7r3r<r:r> _QuadTyper2_TripleOrOptionalQuadType_TripleOrTriplePathType_TripleOrQuadPathPatternType_TripleOrQuadPatternType_TripleOrQuadSelectorTyper;r?r9r=r6_TCArgTc^\rSrSr%SrS\S'S\S'S\S'S\S'S]S^U4S jjjr\S_S j5r\S`S j5r \SaS j5r \ RSbSj5r ScSjr ScSjr SdSjrSeSjrSdSjrSdSjrSfSgSjjrSfShSjjrSiSjrSjSjrSkSjr\SlSj5r\SmSj5r\SnSj5rSnSjrSrSoSjrSpS jrSqS!jrSoS"jrSoS#jrSrS$jrSrS%jr SsS&jr!SrS'jr"SsS(jr#StS)jr$StS*jr%SuS+jr&SuS,jr'SuS-jr(SuS.jr)\&r*\'r+SvS/jr,SwSxS0jjr-SwSyS1jjr.SwSzS2jjr/S{S|S3jjr0S{S}S4jjr1S{S~S5jjr2SSS6jjr3\SSS7jj5r4\SSS8jj5r4\SSS9jj5r4\SSS:jj5r4S \5RhS S S;4SS<jjr4SS=jr6SSS>jjr7SSS?jjr8SSS@jjr9SSAjr:SSSBjjr;SSSCjjr\SSFj5r?\SSSGjj5r?\SSSHjj5r?\SSSIjj5r?\SSSJjj5r?SSSKjjr?SSSLjjr@SSSMjjrASSSNjjrBSSSOjjrCSSSPjjrDSSQjrESsSRjrFSrSSjrGSSTjrHSSUjrISSVjrJSSWjrKSSSXjjrLSSSYjjrMS S;SZ.SS[jjrNS\rOU=rP$)rAia An RDF Graph: a Python object containing nodes and relations between them as RDF 'triples'. This is the central RDFLib object class and Graph objects are almost always present in all uses of RDFLib. Example: The basic use is to create a Graph and iterate through or query its content: ```python >>> from rdflib import Graph, URIRef >>> g = Graph() >>> g.add(( ... URIRef("http://example.com/s1"), # subject ... URIRef("http://example.com/p1"), # predicate ... URIRef("http://example.com/o1"), # object ... )) # doctest: +ELLIPSIS )> >>> g.add(( ... URIRef("http://example.com/s2"), # subject ... URIRef("http://example.com/p2"), # predicate ... URIRef("http://example.com/o2"), # object ... )) # doctest: +ELLIPSIS )> >>> for triple in sorted(g): # simple looping ... print(triple) (rdflib.term.URIRef('http://example.com/s1'), rdflib.term.URIRef('http://example.com/p1'), rdflib.term.URIRef('http://example.com/o1')) (rdflib.term.URIRef('http://example.com/s2'), rdflib.term.URIRef('http://example.com/p2'), rdflib.term.URIRef('http://example.com/o2')) >>> # get the object of the triple with subject s1 and predicate p1 >>> o = g.value( ... subject=URIRef("http://example.com/s1"), ... predicate=URIRef("http://example.com/p1") ... ) ``` Args: store: The constructor accepts one argument, the "store" that will be used to store the graph data with the default being the [`Memory`][rdflib.plugins.stores.memory.Memory] (in memory) Store. Other Stores that persist content to disk using various file databases or Stores that use remote servers (SPARQL systems) are supported. All [builtin storetypes][rdflib.plugins.stores] can be accessed via their registered names. Other Stores not shipped with RDFLib can be added as plugins, such as [HDT](https://github.com/rdflib/rdflib-hdt/). Registration of external plugins is described in [`rdflib.plugin`][rdflib.plugin]. 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. Even if used with a context-aware store, Graph will only expose the quads which belong to the default graph. To access the rest of the data the `Dataset` class can be used instead. 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 the RDFLib `Dataset` class and the TriG Specification, . identifier: identifier of the graph itself namespace_manager: Used namespace manager. Create with bind_namespaces if `None`. base: Base used for [URIs][rdflib.term.URIRef] bind_namespaces: Used bind_namespaces for namespace_manager Is only used, when no namespace_manager is provided. bool context_aware formula_aware default_union Optional[str]baseNc>[[U] 5 X@lU U=(d [ 5Ul[ UR [5(d[UR 5UlU [ U[5(d([R"U[5"5=Ul nOXl X0l XPlSUlSUlSUlgNF)superrA__init__r\r(_Graph__identifier isinstancer*r/r'pluginget _Graph__store_Graph__namespace_manager_bind_namespacesrXrYrZ)selfstore identifiernamespace_managerr\bind_namespaces __class__s F/home/james-whalen/.local/lib/python3.13/site-packages/rdflib/graph.pyr`Graph.__init__s eT#%  &1%'$++^<< &t'8'8 9D  %''#)::eU#;#= =DL5 L#4 /"""cUR$N)rerhs rnri Graph.store"s ||rpcUR$rr)rarss rnrjGraph.identifier&s   rpchURc[XR5UlUR$)z this graph's namespace-manager )rfr rgrss rnrkGraph.namespace_manager*s/  # # +'7>S>S'TD $'''rpcXlgrr)rf)rhnms rnrkrx3s#% rpc>SUR<S[U5<S3$)Nz)rjtyperss rn__repr__Graph.__repr__7s/3T KKrpc[UR[5(a@URR5<SURR R <S3$SURR R -$)Nz9 a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'z'].z?[a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label '%s']].)rbrjr/n3rirm__name__rss rn__str__ Graph.__str__:sf doov . .##%tzz';';'D'DF F W $$--. .rpcU$rrrss rntoPythonGraph.toPythonD rpc<URRU5 U$)z# UHQupp4[U[5(dMURTRLdM8[XU5(dMKXX44v MS g7frr)rbrArj _assertnode.0rrrcrhs rn Graph.addN..|sT # a!U#  / A!$ Q1L#AAA A)readdNrhquadss` rnr Graph.addNys+  #   rpc8URRXS9 U$)zzRemove a triple from the graph If the triple does not provide a context attribute, removes the triple from all contexts. context)reremoverhrs rnr Graph.removes F1 rpcgrrrrs rntriples Graph.triples.1rpcgrrrrs rnrr25rpcgrrrrs rnrr:=rpc## Uup#n[U[5(a"URXU5H upVXSU4v M gURR X#U4US9HuupWphXWU4v M g7f)avGenerator over the triple store. Returns triples that match the given triple pattern. If the triple pattern does not provide a context, all contexts will be searched. Args: triple: A triple pattern where each component can be a specific value or None as a wildcard. The predicate can also be a path expression. Yields: Triples matching the given pattern. rN)rbr$evalrer) rhrrrr_s_o_pcgs rnrrss a a  &&!,Ri-%)LL$8$8!D$8$Q bj %RsA,A.c([U[5(aURURURpCnUcUcUcUR X#U45$UcUcUR U5$UcUcURU5$UcUcURU5$UcURX45$UcURX$5$UcURX#5$X#U4U;$[U[[45(aURU5$[S5e)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 ```python >>> import rdflib >>> g = rdflib.Graph() >>> g.add((rdflib.URIRef("urn:bob"), namespace.RDFS.label, rdflib.Literal("Bob"))) # doctest: +ELLIPSIS )> >>> 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[:namespace.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. !!! example "New in version 4.0" zWYou can only index a graph by a single rdflib term or path, or a slice of rdflib terms.)rbslicestartstopsteprsubject_predicatessubject_objectspredicate_objectssubjects predicatesobjectsr$r- TypeError)rhitemrrrs rn __getitem__Graph.__getitem__sF dE " "jj$))TYY!AyQY19||Q1I..qy..q11qy++A..qy--a00}}Q**q,,||A))ayD(( tTl + +))$/ /i rpc4URRUS9$)zReturns the number of triples in the graph. If context is specified then the number of triples in the context is returned instead. Returns: The number of triples in the graph. r)re__len__rss rnr Graph.__len__s||##D#11rpc$URS5$)zeIterates over all triples in the store. Returns: A generator yielding all triples in the store. NNNrrss rn__iter__Graph.__iter__s ||.//rpc4URU5Hn g g)zSupport for 'triple in graph' syntax. Args: triple: The triple pattern to check for. Returns: True if the triple pattern exists in the graph, False otherwise. TFrrs rn __contains__Graph.__contains__sll6*F+rpc,[UR5$rr)hashrjrss rn__hash__Graph.__hash__#sDOO$$rpcUcg[U[5(a3URUR:URUR:- $g)NrbrArjrhothers rn__cmp__ Graph.__cmp__&sJ = u % %OOe&6&66%"2"22 rpcb[U[5=(a URUR:H$rrrrs rn__eq__ Graph.__eq__3s#%'ODOOu?O?O,OOrpcxUSL=(d0 [U[5=(a URUR:$rrrrs rn__lt__ Graph.__lt__6s1  ue $ K5;K;K)K rpc X:=(d X:H$rrrrs rn__le__ Graph.__le__;|,t},rpcx[U[5=(a URUR:=(d USL$rrrrs rn__gt__ Graph.__gt__>s25%(OT__u?O?O-O   rpc X:=(d X:H$rrrrs rn__ge__ Graph.__ge__Crrpc>^TRU4SjU55 T$)zCAdd all triples in Graph other to Graph. BNode IDs are not changed.c32># UH upo1X#T4v M g7frrr)rrrrrhs rnr!Graph.__iadd__..Is7gaAaD/srrs` rn__iadd__Graph.__iadd__Fs 777 rpc:UHnURU5 M U$)zJSubtract all triples in Graph other from Graph. BNode IDs are not changed.)r)rhrrs rn__isub__Graph.__isub__LsF KK  rpcp[U5"5n[[ UR 55[ UR 55-5Hup4UR X45 M UHnURU5 M UHnURU5 M U$![a [5nNf=f)z.Set-theoretic union BNode IDs are not changed.)r|rrAsetlist namespacesbindr)rhrretvalprefixurixys rn__add__ Graph.__add__Ss $Z\FtDOO$56e>N>N>P9QQRKF KK $SA JJqMA JJqM  WF sBB54B5c[U5"5nUHnX0;dM URU5 M U$![a [5nN9f=f)z6Set-theoretic intersection. BNode IDs are not changed.r|rrArrhrrrs rn__mul__ Graph.__mul__bsM $Z\FAy 1   WF 5A  A c[U5"5nUHnX1;dM URU5 M U$![a [5nN9f=f)z4Set-theoretic difference. BNode IDs are not changed.rrs rn__sub__ Graph.__sub__nsM $Z\FA~ 1   WF rcX- X- -$)z-Set-theoretic XOR. BNode IDs are not changed.rrs rn__xor__ Graph.__xor__zs ..rpcUup#nUcS5eUcS5eURX#S45 URX#U45 U$)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, *, *))rr)rhrsubject predicateobject_s rnr  Graph.setsg)/%W   L K L   ! L K L ! W./ 'g./ rpc## [U[5(a'UH nURXU5HnUv M M" gU(d"URSX45H upVnUv M g[ 5nURSX45H#upVnXX;dM Uv UR U5 M% g![ an [RU S35 eSn A ff=f7f)a/A generator of (optionally unique) subjects with the given predicate and object(s) Args: predicate: A specific predicate to match or None to match any predicate. object: A specific object or list of objects to match or None to match any object. unique: If True, only yield unique subjects. N1. Consider not setting parameter 'unique' to True) rbr rrr r MemoryErrorloggererror) rhr%objectuniqueobjrrrsubses rnrGraph.subjectss fd # #yv>AG?#||T9,EFGA!G Gu#||T9,EFGA!}" HHQK G +""LL#$#%V W" "0B CCB-(C- C7CCCc#@# U(d#URUSU45H upEnUv M g[5nURUSU45H#upEnXW;dM Uv URU5 M% g![an[R US35 eSnAff=f7f)a;Generate predicates with the given subject and object. Args: subject: A specific subject to match or None to match any subject. object: A specific object to match or None to match any object. unique: If True, only yield unique predicates. Yields: Predicates matching the given subject and object. Nr)rr rr*r+r,) rhr$r-r.rrrpredsr1s rnrGraph.predicatess <<$(?@aAEE<<$(?@a>G ! A '  c!RS s0ABBA3.B3 B=BBBc## [U[5(a'UH nURXBU5HnUv M M" gU(d"URXS45H upgnUv M g[ 5nURXS45H#upgnXX;dM Uv UR U5 M% g![ an [RU S35 eSn A ff=f7f)asA generator of (optionally unique) objects with the given subject(s) and predicate Args: subject: A specific subject or a list of subjects to match or None to match any subject. predicate: A specific predicate to match or None to match any predicate. unique: If True, only yield unique objects. Yields: Objects matching the given subject and predicate. Nr)) rbr rrr rr*r+r,) rhr$r%r.subjrrrobjsr1s rnr Graph.objectss" gt $ $dv>AG? #||W,FGGA!G Hu#||W,FGGA!}" HHQK H +""LL#$#%V W" "r3c#J# U(d$URSSU45H up4nX44v M g[5nURSSU45H'up4nX44U;dMX44v URX445 M) g![an[R US35 eSnAff=f7f)zSA generator of (optionally unique) (subject, predicate) tuples for the given objectNr)r5)rhr-r.rrr subj_predsr1s rnrGraph.subject_predicatess <<tV(<=ad >J<<tV(<=a6+$J"v. > '  c!RS 0AB#B#!A83B#8 B BB  B#c#J# U(d$URSUS45H up4nX54v M g[5nURSUS45H'up4nX54U;dMX54v URX545 M) g![an[R US35 eSnAff=f7f)zSA generator of (optionally unique) (subject, object) tuples for the given predicateNr)r5)rhr%r.rrr subj_objsr1s rnrGraph.subject_objectss<<y$(?@ad AI<<y$(?@a6*$J! qf- A '  c!RS r?c#J# U(d$URUSS45H up4nXE4v M g[5nURUSS45H'up4nXE4U;dMXE4v URXE45 M) g![an[R US35 eSnAff=f7f)zSA generator of (optionally unique) (predicate, object) tuples for the given subjectNr)r5)rhr$r.rrr pred_objsr1s rnrGraph.predicate_objects-s <<$(=>ad ?I<<$(=>a6*$J! qf- ? '  c!RS r?c#r# Uup4nURRX4U4US9HuupgpXgU4v M g7f)Nr)ritriples_choices) rhrrr$r%r&rrrrs rnrGGraph.triples_choicesBsL '-#G"ZZ77  )48 MIQ1'M s57cgrrrrhr$r%r-defaultanys rnvalue Graph.valueOrpcgrrrrJs rnrMrNYrOrpcgrrrrJs rnrMrNcrOrpcgrrrrJs rnrMrNmsrpTc  UnUcUb UcUbUcUcgUcURX5nUcURX#5nUcURX5n[W5nUSLa|[U5 SU<SU<SU<S3nURR XU4S5n U H'uuppUSU <SU <SU <S[ U 5<S3 - nM) [R"U5eU$![a U$f=f![a UnU$f=f) 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 Args: subject: Subject of the triple pattern, exactly one of subject, predicate, object must be None predicate: Predicate of the triple pattern, exactly one of subject, predicate, object must be None object: Object of the triple pattern, exactly one of subject, predicate, object 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 NFz"While trying to find a value for (z, z-) the following multiple values where found: (z) (contexts: z) ) rrrnextrirr  exceptionsUniquenessError StopIteration)rhr$r%r-rKrLrvaluesmsgrrrrcontextss rnrMrNws<._!2FN!fn >\\'5F ?]]95F  __W5F &\Fe|L#Iv7 #jj00'f1MtTG/6+ q N  07%44S99!& % ) F* - s% C3$A;C"" C0/C03 DDc## [U/5nU(arURU[R5nUbUv URU[R5nX;a [ S5eUR U5 U(aMqgg7f)z_Generator over all items in the resource specified by list Args: list: An RDF collection. Nz,List contains a recursive rdf:rest reference)r rMrfirstrest ValueErrorr)rhr chainrs rnitems Graph.itemssk TF ::dCII.D ::dCHH-D} !OPP IIdOds BB B c## Uc0nOX#;agSX2'U"X 5H$nUv URXU5HnUv M M& g7f)a~Generates transitive closure of a user-defined function against the graph ```python 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,namespace.RDFS.label)) g.add((b,RDF.rest,c)) g.add((c,RDF.first,namespace.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)] # [rdflib.term.BNode('baz'), # rdflib.term.BNode('bar'), # rdflib.term.BNode('foo')] [rt for rt in g.transitiveClosure( reverseList,RDF.nil)] # 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')] ``` Args: func: A function that generates a sequence of nodes arg: The starting node seen: A dict of visited nodes Nr)transitiveClosure)rhfuncargseenrtrt_2s rnrdGraph.transitiveClosuresPd <D [  s/BH..t> ?"sAAc## Uc0nX;agSX1'Uv URX5H nURXBU5HnUv M M" g7f)aJTransitively generate objects for the ``predicate`` relationship Generated objects belong to the depth first transitive closure of the `predicate` relationship starting at `subject`. Args: subject: The subject to start the transitive closure from predicate: The predicate to follow remember: A dict of visited nodes Nr)rtransitive_objects)rhr$r%rememberr-rs rnrlGraph.transitive_objectssX  H    ll76F,,VIJ7A A c## Uc0nX#;agSX2'Uv URX5H nURXU5HnUv M M" g7f)aITransitively generate subjects for the ``predicate`` relationship Generated subjects belong to the depth first transitive closure of the `predicate` relationship starting at `object`. Args: predicate: The predicate to follow object: The object to start the transitive closure from remember: A dict of visited nodes Nr)rtransitive_subjects)rhr%r-rmr$rs rnrqGraph.transitive_subjectssX  H    }}Y7G--i(KL8roc8URRU5$rr)rkqnamerhrs rnrt Graph.qname9s%%++C00rpc8URRX5$rr)rk compute_qnamerhrgenerates rnrxGraph.compute_qname<s%%33CBBrpc6URRXX4S9$)aBind 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 Args: prefix: The prefix to bind namespace: The namespace to bind the prefix to override: If True, override any existing prefix binding replace: If True, replace any existing namespace binding Example: ```python graph.bind("foaf", "http://xmlns.com/foaf/0.1/") ``` )overridereplace)rkr)rhr namespacer}r~s rnr Graph.bind?s(@%%** +  rpc#\# URR5H upX4v M g7f)zjGenerator over all the prefix, namespace tuples Returns: Generator yielding prefix, namespace tuples N)rkr)rhrrs rnrGraph.namespacescs- "&!7!7!B!B!D F# #"Es*,c8URRX5$)z5Turn uri into an absolute URI if it's not one already)rk absolutizerhrdefrags rnrGraph.absolutizels%%00==rpc grrrrh destinationformatr\encodingargss rn serializeGraph.serializeqrpc grrrrs rnrr|rpc grrrrs rnrrrpc grrrrs rnrrrrpc grrrrs rnrr$'rpc Uc URn[R"U[5"U5nUcg[ 5nUc5UR "U4USS.UD6 UR 5RS5$UR "U4X4S.UD6 UR 5$[US5(a.[[[U5nUR "U4X4S.UD6 U$[U[R5(a [U5nOI[[U5n [!U 5upppU S:Xa"U S:wa[#SU <S35e[%U 5nOU n['US 5nUR "U4X4S.UD6 SSS5 U$!,(df  U$=f) a=Serialize the graph. Args: destination: The destination to serialize the graph to. This can be a path as a string or pathlib.PurePath object, or it can be an IO[bytes] like object. If this parameter is not supplied the serialized graph will be returned. format: The format that the output should be written in. This value references a Serializer plugin. Format support is managed with [plugins][rdflib.plugin]. Defaults to "turtle" and some other formats are builtin, like "xml" and "trix". See also [serialize module][rdflib.plugins.parsers]. base: The base IRI for formats that support it. For the turtle format this will be used as the @base directive. encoding: Encoding of output. args: Additional arguments to pass to the Serializer that will be used. Returns: The serialized graph if `destination` is None. The serialized graph is returned as str if no encoding is specified, and as bytes if an encoding is specified. self (i.e. the Graph instance) if `destination` is not None. Nutf-8)r\rwritefilez the file URI z2 has an authority component which is not supportedwb)r\rcrdr&rrgetvaluedecodehasattrrrbytesrbpathlibPurePathstrrr_rr)rhrrr\rr serializerstreamos_pathlocationschemenetlocpathparams_queryfragments rnrrsB <99DZZ 3D9  YF$$VQ$QDQ(//88$$VR$RTR(( ; ( ("U)[1F   Nd N N" +w'7'788k*[1AI(AS>fV#|(+H<7ij+40G&Ggt$$$VR$RTR% %$ s E:: F cT[URSXS9RU5USS9 g)N)rrT)rflush)printrr)rhrrouts rnr Graph.prints-  NN4N B I I( S rpc [UUUUUUS9nUc URnSnUc[US5(ax[URSS5(a\[ URR [5(a3[RRURR 5nUcSnSn[R"U[5"5n U R "X40UD6 UR&(aUR)5 U$![Raf [RR[ U[5(dUO [U55nUce[R"U[5"5n Nf=f!["an U(a[%SU-5eU eSn A ff=f!UR&(aUR)5 ff=f) a Parse an RDF source adding the resulting triples to the Graph. The source is specified using one of source, location, file or data. Args: source: An `xml.sax.xmlreader.InputSource`, file-like object, `pathlib.Path` like object, or string. In the case of a string the string is the location of the source. publicID: The logical URI to use as the document base. If None specified the document location is used (at least in the case where there is a document location). This is used as the base URI when resolving relative URIs in the source document, as defined in `IETF RFC 3986 `_, given the source document does not define a base URI. format: Used if format can not be determined from source, e.g. file extension or Media Type. Format support is managed with [plugins][rdflib.plugin]. Available formats are e.g. "turle", "xml", "n3", "nt" and "trix" or see [parser module][rdflib.plugins.parsers]. location: A string indicating the relative or absolute URL of the source. `Graph`'s absolutize method is used if a relative location is specified. file: A file-like object. data: A string containing the data to be parsed. args: Additional arguments to pass to the parser. Returns: self, i.e. the Graph instance. Example: ```python >>> my_data = ''' ... ... ... Example ... This is really just an example. ... ... ... ''' >>> import os, tempfile >>> fd, file_name = tempfile.mkstemp() >>> f = os.fdopen(fd, "w") >>> dummy = f.write(my_data) # Returns num bytes written >>> 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) >>> # default turtle parsing >>> result = g.parse(data=" .") >>> len(g) 3 ``` !!! warning "Caution" This method can access directly or indirectly requested network or file resources, for example, when parsing JSON-LD documents with `@context` directives that point to a network location. When processing untrusted or potentially malicious documents, measures should be taken to restrict network and file access. For information on available security measures, see the RDFLib [Security Considerations](../security_considerations.md) documentation. sourcepublicIDrrdatarNFrnameturtleTzCould not guess RDF format for %r from file extension so tried Turtle but failed.You can explicitly specify format using the format argument.)r# content_typergetattrrrbrrrdflibutil guess_formatrcrdr"PluginExceptionr!parse SyntaxErrorr auto_closer) rhrrrrrrrcould_not_guess_formatparserses rnr Graph.parsesD%   >((F!& >''FKK66v{{//5511&++2B2BC~!)-& 2ZZ/1F  LL . .    3%% 2[[--(==3v;F~ZZ/1F 2 %!S     !s74 D F A7FF F/F**F//F22$Gc U=(d 0nU=(d [UR55nUR(aSnO8[U[5(aUR R nO UR n[URS5(a(U(a!URR"UUUU40UD6$[U[R5(d3[R"[[U5[R5n[U[R 5(d+[R"U[R 5"U5nU"UR"XU40UD65$![a Nf=f)a Query this graph. Args: query_object: The query string or object to execute. processor: The query processor to use. Default is "sparql". result: The result format to use. Default is "sparql". initNs: Initial namespaces to use for resolving prefixes in the query. If none are given, the namespaces from the graph's namespace manager are used. initBindings: Initial variable bindings to use. A type of 'prepared queries' can be realized by providing these bindings. use_store_provided: Whether to use the store's query method if available. kwargs: Additional arguments to pass to the query processor. Returns: A [`rdflib.query.Result`][`rdflib.query.Result`] instance. !!! warning "Caution" This method can access indirectly requested network endpoints, for example, query processing will attempt to access network endpoints specified in `SERVICE` directives. When processing untrusted or potentially malicious queries, measures should be taken to restrict network and file access. For information on available security measures, see the RDFLib [Security Considerations](../security_considerations.md) documentation. __UNION__query)dictrrZrbrDdefault_contextrjrrirNotImplementedErrorResultrcrdrr Processor) rh query_object processorresultinitNs initBindingsuse_store_providedkwargs query_graphs rnr Graph.querys*P$)r 24 12   %K . / /..99K//K 4::w ' ',> zz''     &%,,//ZZS& 15<<@F)U__55 9eoo>tDIiool&SFSTT'  sE33 F?Fc VU=(d 0nU=(d [UR55nUR(aSnO8[U[5(aUR R nO UR n[URS5(a(U(a!URR"UUUU40UD6$[U[R5(d+[R"U[R5"U5nUR"XU40UD6$![a Njf=f)aUpdate this graph with the given update query. Args: update_object: The update query string or object to execute. processor: The update processor to use. Default is "sparql". initNs: Initial namespaces to use for resolving prefixes in the query. If none are given, the namespaces from the graph's namespace manager are used. initBindings: Initial variable bindings to use. use_store_provided: Whether to use the store's update method if available. kwargs: Additional arguments to pass to the update processor. !!! warning "Caution" This method can access indirectly requested network endpoints, for example, query processing will attempt to access network endpoints specified in `SERVICE` directives. When processing untrusted or potentially malicious queries, measures should be taken to restrict network and file access. For information on available security measures, see the RDFLib Security Considerations documentation. rupdate)rrrZrbrDrrjrrirrrUpdateProcessorrcrd)rh update_objectrrrrrrs rnr Graph.updates>$)r 24 12   %K . / /..99K//K 4::x ( (-? zz((!    )U%:%:;; 9e.C.CDTJI VNvNN '  sD D('D(c:SURRUS9-$)%Return an n3 identifier for the Graphz[%s]rkrjrrhrks rnrGraph.n3  **=N*OOOrpc>[URUR44$rr)rArirjrss rn __reduce__Graph.__reduce__s"     rpcF[U5[U5:wagUH>up#n[U[5(aM[U[5(aM4X#U4U;dM> g UH>up#n[U[5(aM[U[5(aM4X#U4U;dM> g g)a{Check if this graph is isomorphic to another graph. Performs a basic check if these graphs are the same. If no BNodes are involved, this is accurate. Args: other: The graph to compare with. Returns: True if the graphs are isomorphic, False otherwise. Note: This is only an approximation. See rdflib.compare for a correct implementation of isomorphism checks. FT)lenrbr()rhrrrrs rn isomorphicGraph.isomorphics" t9E "GA!a'' 1e0D0DayE) GA!a'' 1e0D0DayD(  rpc[UR55n/nU(dgU[R"[ U55/nU(aUR 5nXB;aUR U5 URUS9H"nXR;dM XS;dMUR U5 M$ URUS9H"nXR;dM XS;dMUR U5 M$ U(aM[ U5[ U5:Xagg)adCheck if the Graph is connected. The Graph is considered undirectional. Returns: True if all nodes have been visited and there are no unvisited nodes left, False otherwise. Note: 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. F)r$)r-T) r  all_nodesrandom randrangerpopappendrr)rhr discoveredvisitingrnew_xs rn connectedGraph.connected5s)*  f..s9~>?@ A"!!!$a0*u/DOOE*1a0*u/DOOE*1h y>S_ ,rpcv[UR55nURUR55 U$rr)r rrr)rhress rnrGraph.all_nodes^s)$,,.! 4==?# rpc[X5$)aCreate a new `Collection` instance. Args: identifier: A URIRef or BNode instance. Returns: A new Collection instance. Example: ```python >>> 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) ] ``` rrhrjs rn collectionGraph.collectioncs,$++rpcX[U[5(d [U5n[X5$)aCreate a new ``Resource`` instance. Args: identifier: A URIRef or BNode instance. Returns: A new Resource instance. Example: ```python >>> 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 ``` )rbr-r/r%rs rnresourceGraph.resource{s&(*d++ +J))rpcbURS5HnURU"U55 M g)Nr)rr)rhtargetrets rn_process_skolem_tuplesGraph._process_skolem_tupless(01A JJtAw 2rpc^^^^SUU4SjjmSUU4SjjnUc [5OUnTcURXe5 U$[T[5(aURUUU4Sj5 U$)Nc>Uup#nX :Xa2[(a[U[5(deURTTS9nX@:Xa2[(a[U[5(deURTTS9nX#U4$N) authoritybasepath)rrbr( skolemize)bnoderrrrr r s rn do_skolemize%Graph.skolemize..do_skolemizessIQ1z =%a////KK)hKGz =%a////KK)hKG7Nrpc>Uupn[U[5(aURTTS9n[U[5(aURTTS9nXU4$r)rbr(r )rrrrr r s rn do_skolemize2&Graph.skolemize..do_skolemize2sSIQ1!U##KK)hKG!U##KK)hKG7Nrpc>T"TU5$rrr)rr r s rn!Graph.skolemize..s ,ua:Prp)r r(rr6returnr6rr6rr6)rArrbr()rh new_graphr r r rrr s ``` @rnr Graph.skolemizesf    &-9 =  ' ' >  u % %  ' '0P Q rpc^^SSjmSSjnUc [5OUnTcURXC5 U$[T[5(aURUUU4Sj5 U$)NcUup#nX :Xa2[(a[U[5(deUR5nX@:Xa2[(a[U[5(deUR5nX#U4$rr)rrbr/ de_skolemize)urirefrrrrs rndo_de_skolemize+Graph.de_skolemize..do_de_skolemizesfIQ1{ =%a0000NN${ =%a0000NN$7NrpcUupn[R"U5(a[U5R5nO4[R"U5(a[U5R5n[ U[ 5(ai[R"U5(a[U5R5nO4[R"U5(a[U5R5nXU4$rr)r._is_rdflib_skolemrr)_is_external_skolemrbr/)rrrrs rndo_de_skolemize2,Graph.de_skolemize..do_de_skolemize2sIQ1,,Q//N//1**1--!H))+!V$$0033#A335A..q11a--/A7Nrpc>T"TU5$rrr)rrrs rnr$Graph.de_skolemize..s /&RS:Trp)rr/rr6rr6r)rArrbr))rhrrr"rrs ` @rnrGraph.de_skolemizes\  $&-9 >  ' ' A   & &  ' '0T U rp) target_graphinclude_reificationscT^^^^Uc [5mOUmSUUUU4SjjmT"U5 T$)aaRetrieves the Concise Bounded Description of a Resource from a Graph. Args: resource: A URIRef object, the Resource to query for. target_graph: Optionally, a graph to add the CBD to; otherwise, a new graph is created for the CBD. include_reifications: If False, skip Rule 3 to exclude reified statements (default: True) Returns: A Graph, subgraph of self if no graph was provided otherwise the provided graph. Note: Concise Bounded Description (CBD) is defined as: Given a particular node (the starting node) in a particular RDF graph (the source graph), a subgraph of that particular graph, taken to comprise a concise bounded description of the resource denoted by the starting node, can be identified as follows: 1. Include in the subgraph all statements in the source graph where the subject of the statement is the starting node; 2. Recursively, for all statements identified in the subgraph thus far having a blank node object, include in the subgraph all statements in the source graph where the subject of the statement is the blank node in question and which are not already included in the subgraph. 3. Recursively, for all statements included in the subgraph thus far, for all reifications of each statement in the source graph, include the concise bounded description beginning from the rdf:Statement node of each reification. This results in a subgraph where the object nodes are either URI references, literals, or blank nodes not serving as the subject of any statement in the graph. If include_reifications is set to False, Rule 3 above will be skipped, meaning reified statements will not be included in the CBD. This can improve performance when reified statements are not present or can be used to deliberately exclude them from the result. cj>T (a0nT R[RU5HpnT RU[R5nT RU[R 5nUcMHUcMMXU4nXQ;aU1X'M]XR U5 Mr T RUSS45H}upcnT R XcU45 [U5[LaUSS4T ;aT"U5 T (dMEWRXcU4[55nUHnUSS4T ;dMT"U5 M M grr) rrr$rMr%r-rrr|r(rdr ) r reif_indexstmtrrrrstmts add_to_cbdr(rhsubgraphs rnr.Graph.cbd..add_to_cbds$CE  MM#++s;D(, 4(GA 44A}"%!!326J.&.2248< <<dD(9:a aAY'7e#D$x(GqM('&NNA!9ceB B0+/ ! (  , (+"% &      +."% '      .1"% ,      +..1(+"% ',&      +/.1ii(,"& ?'?,?& ?  ?  ? ?B*.2 :;::+ :@AE ',>  7 <@D +&=  6 41C " " "  "  "  " H$>        !      !       !"% <      JM!"% 'F'' '  '  ' "''JN""& AAFAA A  A  A $AJ $          "& $"&26,0R R  R  R R0R*RR Rn2:19.2;?#'CU'CU/CU/ CU , CU 9 CU!CUCU CUP?G.2;?#' 8O)8O<8O, 8O 9 8O ! 8O8O 8OtP <'R ,0*0  #G  &*!%#'"& #"##! #  #  #LMQ)()9I) )^&*%) UU# U # U  UUrpcT^\rSrSr%SrS\S'S&S'U4Sjjjr\S5r\RS5rS(Sjr \ S)S*S jj5r \ S)S+S jj5r \ S)S,S jj5r \ S)S-S jj5r \ S)S.S jj5r \ S)S/Sjj5r S)S/Sjjr S0Sjr S1Sjr\ S2Sj5r\ S3Sj5rS4SjrS5SjrS1Sjr\ S6S7Sjj5r\ S6S8Sjj5r\ S6S9Sjj5rS:S9SjjrS:S;SjjrS:SSjjrS?SjrS@SAS jjrSBS!jrS:SCS"jjrSDSES#jjrSFS$jrS%rU=r$)GrDiDaA ConjunctiveGraph is an (unnamed) aggregation of all the named graphs in a store. !!! warning "Deprecation notice" ConjunctiveGraph is deprecated, use [`rdflib.graph.Dataset`][rdflib.graph.Dataset] instead. It has a `default` graph, whose name is associated with the graph throughout its life. Constructor 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. r5_default_contextc6>[[U] XS9 [U5[La[R "S[ SS9 URR(dS5eSUlSUl [URU=(d [5US9Ul g)N)rjz4ConjunctiveGraph is deprecated, use Dataset instead. stacklevelz9ConjunctiveGraph must be backed by a context aware store.Trirjr\) r_rDr`r|warningswarnDeprecationWarningrirXrZrAr(rw)rhrirjdefault_graph_baserms rnr`ConjunctiveGraph.__init__Ws .u.L :) ) MMF"  zz'' J '"!.3**)>uwEW/ rpcUR$rrrwrss rnr ConjunctiveGraph.default_contexto$$$rpcXlgrrrrhrMs rnrrs %rpcJSnXRRR-$)NzK[a rdflib:ConjunctiveGraph;rdflib:storage [a rdflib:Store;rdfs:label '%s']]rirmrrhpatterns rnrConjunctiveGraph.__str__ws' 0 --6666rpcgrrrrhtriple_or_quadrKs rn_spocConjunctiveGraph._spoc~s rpcgrrrrs rnrr  rpcgrrrrs rnrrs 47rpcgrrrrs rnrrs rpcgrrrrs rnrrrrpcgrrrrs rnrrrrpcUcSSSU(a UR4$S4$[U5S:XaU(a UROSnUupEnO%[U5S:XaUupEpcURU5nWWWW4$)zG helper method for having methods that support either triples or quads N)rr_graph)rhrrKrrrrs rnrrs  !$gd&:&:P P4P P ~ ! #(/$$TA&IQ1  A %)LQ1 AA!Qzrpc^URU5up#pEURX#U4US9Hn g g)z)Support for 'triple/quad in graph' syntaxrTF)rr)rhrrrrrrs rnrConjunctiveGraph.__contains__s5ZZ/ aqQi3A4rpc~URUSS9up#pE[X#U5 URRX#U4USS9 U$)z\Add a triple or quad to the store. if a triple is given it is added to the default context TrKF)rr)rrrirrhrrrrrs rnrConjunctiveGraph.addsEZZZ= aA! ay!E: rpcgrrrrhrs rnrConjunctiveGraph._graphsMPrpcgrrrrs rnrrs'*rpcUcg[U[[45(aU$[U[5(aUR UR 5$UR U5$rr)rbrFrDrA get_contextrjrs rnrrsW 9 a'#34 5 5H a  ##ALL1 1""rpcR^TRRU4SjU55 T$)z&Add a sequence of triples with contextc3x># UH/upp4[XU5(dMXUTRU54v M1 g7frr)rrrs rnr(ConjunctiveGraph.addN..s4 8=*!QSTAU %Q1dkk!n %s::rirrs` rnrConjunctiveGraph.addNs)  8=   rpcfURU5up#pEURRX#U4US9 U$)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 r)rrirrs rnrConjunctiveGraph.removes6 ZZ/ a 1)Q/ rpcgrrrrhrrs rnrConjunctiveGraph.tripless .1rpcgrrrrs rnrr s 25rpcgrrrrs rnrr s :=rpc## URU5up4pVURU=(d U5nUR(aX R:XaSnOUc URn[ U[ 5(a'UcUnUR X#U5H up5X4U4v M gURRX4U4US9Huup4pWX4U4v M g7f)zIterate 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. Nr) rrrZrrbr$rrir)rhrrrrrrrs rnrr sZZ/ a++gl+   ..... a  w1-Ag ."&!3!3Q1Iw!3!O qAg "PsC Cc## URU5up#pEURRX#U4US9Huup#pFUH nX#XG4v M M g7f)z:Iterate over all the quads in the entire conjunctive graphrN)rrir)rhrrrrrrctxs rnrConjunctiveGraph.quads4 sV ZZ/ a!ZZ//q 1/EMIQ1Al"FsA Ac## Uup4nUcUR(d URnOURU5nURR X4U4US9HuupgpXgU4v M g7f)z[URUR44$rr)rDrirjrss rnrConjunctiveGraph.__reduce__ s$**doo!>>>rp)rwrXrZ)rKNN)rir7rjz$Optional[Union[IdentifiedNode, str]]rr[r:r;)rrOrKrWrrO)rz%Union[_TripleType, _OptionalQuadType]rKrWrr7)rr1rKrWrz(Tuple[None, None, None, Optional[Graph]])r"Optional[_TripleOrQuadPatternType]rKrWrr:)rrTrKrWrr>)rz#Optional[_TripleOrQuadSelectorType]rKrWrr>rrTrrW)rhrCrrPrrC)rz)Union[Graph, _ContextIdentifierType, str]rrA)rr1rr1)rz3Optional[Union[Graph, _ContextIdentifierType, str]]rrh)rhrCrr>rrC).)rrSrrNrr@)rrRrrNrrB)rrTrrNrrDrr)rrrz(Generator[_OptionalQuadType, None, None]rLrErzOptional[_TripleType]rz#Generator[_ContextType, None, None])rjr8rzUnion[Graph, None])FN)rjr8rrWr\r[rrA)rr5rr1)rrrr[rr/r]r^rf)rrjrkrlrmrnr`rorrprrrrrrrrrrrGrr[rrrrrrrsrtrus@rnrDrDDs: #"$-;?,0    9 *   0%%&&7!    =      777 2 77 :    1       ;      ;  * 1 "PP ** # > #  # )<  +.101(1 , 11 +.545(5 0 55 +.=1=(= 8 ==+/1( 8 BDH #@ # 1 #+/!( , "$ /30+0 ,0"M"  @      "7, "& $"&26,0I I  I  I I0I*II IV??rpzurn:x-rdflib:defaultc ^\rSrSrSrSSU4Sjjjr\S5r\RS5r\S5r \ RS5r \U4Sj5r SS jr S S jr S!S jr S"S jrS#S jrS$S%SjjrS&S'SjjrS(SjrS)SjrS*S+U4SjjjrS*S+U4SjjjrS*S,U4SjjjrS-Sjr\S.Sj5r\S/S.Sjj5r\S0S1Sjj5r\S/S2Sjj5r\S0S3Sjj5rS4S3U4SjjjrSrU=r$)5rFi aV An RDFLib Dataset is an object that stores multiple Named Graphs - instances of RDFLib Graph identified by IRI - within it and allows whole-of-dataset or single Graph use. RDFLib's Dataset class is based on the [RDF 1.2. 'Dataset' definition](https://www.w3.org/TR/rdf12-datasets/): An RDF dataset is a collection of RDF graphs, and comprises: - Exactly one default graph, being an RDF graph. The default graph does not have a name and MAY be empty. - Zero or more named graphs. Each named graph is a pair consisting of an IRI or a blank node (the graph name), and an RDF graph. Graph names are unique within an RDF dataset. Accordingly, a Dataset allows for `Graph` objects to be added to it with [`URIRef`][rdflib.term.URIRef] or [`BNode`][rdflib.term.BNode] identifiers and always creats a default graph with the [`URIRef`][rdflib.term.URIRef] identifier `urn:x-rdflib:default`. Dataset extends Graph's Subject, Predicate, Object (s, p, o) 'triple' structure to include a graph identifier - archaically called Context - producing 'quads' of s, p, o, g. Triples, or quads, can be added to a Dataset. Triples, or quads with the graph identifer :code:`urn:x-rdflib:default` go into the default graph. !!! warning "Deprecation notice" Dataset builds on the `ConjunctiveGraph` class but that class's direct use is now deprecated (since RDFLib 7.x) and it should not be used. `ConjunctiveGraph` will be removed from future RDFLib versions. Examples of usage and see also the `examples/datast.py` file: ```python >>> # 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") ... )) # doctest: +ELLIPSIS )> >>> # 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") ... )) # doctest: +ELLIPSIS )> >>> # 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 ... )) # doctest: +ELLIPSIS )> >>> # 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 >>> # (None) 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")) >>> # unrestricted looping is equivalent to iterating over the entire Dataset >>> for q in ds: # 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")) >>> # resticting iteration to a graph: >>> 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.identifier) # doctest: urn:x-rdflib: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 https://rdflib.github.io/.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) ``` !!! example "New in version 4.0" c>[[U] USS9 URR(d [ S5e[ UR[US9UlX l g)N)rirjz.Dataset must be backed by a graph-aware store!r|) r_rFr`ri graph_aware ExceptionrADATASET_DEFAULT_GRAPH_IDrwrZ)rhrirZrrms rnr`Dataset.__init__q sT gt%Ed%Czz%%LM M %**/#!  +rpcN[R"S[SS9 UR$NzIDataset.default_context is deprecated, use Dataset.default_graph instead.ryrzr}r~rrwrss rnrDataset.default_context s% W  $$$rpcD[R"S[SS9 Xlgrrrs rnrr s W  !&rpcUR$rrrrss rn default_graphDataset.default_graph rrpcXlgrrrrs rnrr rrpcT>[R"S[SS9 [[U]$)NzHDataset.identifier is deprecated and will be removed in future versions.ryrz)r}r~rr_rFrj)rhrms rnrjDataset.identifier s' V  Wd..rpcJSnXRRR-$)NzB[a rdflib:Dataset;rdflib:storage [a rdflib:Store;rdfs:label '%s']]rrs rnrDataset.__str__ s% S --6666rpcH[U5URUR44$rr)r|rirZrss rnrDataset.__reduce__ s T TZZ););<==rpc^URURURUR4$rrrirjrrZrss rn __getstate__Dataset.__getstate__ s%zz4??D,>,>@R@RRRrpc:UuUlUlUlUlgrrr)rhstates rn __setstate__Dataset.__setstate__ s OTK DOT%79Krpc6URSU55 U$)zEAdd all quads in Dataset other to Dataset. BNode IDs are not changed.c30# UH upp4XX44v M g7frrr)rrrrgs rnr#Dataset.__iadd__.. s7:11,srrs rnrDataset.__iadd__ s 777 rpcfUc3SSKJnJn URSX4-SS9 [ 5R 5nSn[ U[5(a[ U[[45(dUnURU5nUbURU5 X&l URRU5 U$)Nr)_SKOLEM_DEFAULT_AUTHORITYrdflib_skolem_genidgenidF)r}) rdflib.termrrrr(r rbrArFrDrrr\ri add_graph)rhrjr\rr graph_to_copyrs rngraph Dataset.graph s   R II)?   **,J)- j% ( ( "232 2 'M KK #  $ JJ} % Qrpc :[R"XX#XEU40UD6 U$)aParse an RDF source adding the resulting triples to the Graph. Args: source: The source to parse. See rdflib.graph.Graph.parse for details. publicID: The public ID of the source. format: The format of the source. location: The location of the source. file: The file object to parse. data: The data to parse. **args: Additional arguments. Returns: The graph that the source was parsed into. Note: The source is specified using one of source, location, file or data. If the source is in a format that does not support named graphs its triples will be added to the default graph (i.e. :attr:`.Dataset.default_graph`). If the source is in a format that does not support named graphs its triples will be added to the default graph (i.e. Dataset.default_graph). !!! warning "Caution" This method can access directly or indirectly requested network or file resources, for example, when parsing JSON-LD documents with `@context` directives that point to a network location. When processing untrusted or potentially malicious documents, measures should be taken to restrict network and file access. For information on available security measures, see the RDFLib Security Considerations documentation. !!! example "Changed in 7.0" The `publicID` argument is no longer used as the identifier (i.e. name) of the default graph as was the case before version 7.0. In the case of sources that do not support named graphs, the `publicID` parameter will also not be used as the name for the graph that the data is loaded into, and instead the triples from sources that do not support named graphs will be loaded into the default graph (i.e. Dataset.default_graph). )rDr)rhrrrrrrrs rnr Dataset.parse s+n  (HD DH  rpc$URU5$)zalias of graph for consistency)rrhrs rnrDataset.add_graph szz!}rpc[U[5(dURU5nURR U5 UbXR :Xa%URR UR 5 U$rr)rbrArri remove_graphrrrs rnrDataset.remove_graph" sb!U##  #A " 9/// JJ !3!3 4 rpc#># [R"S[SS9 Sn[[U]U5HnX#R [:H-nUv M U(dUR[5v gg7f)Nz;Dataset.contexts is deprecated, use Dataset.graphs instead.ryrzF) r}r~rr_rFr[rjrrrhrrKrrms rnr[Dataset.contexts/ sk  I  w.v6A ||'?? ?GG7**56 6sA0A3c#># Sn[[U] U5HnX#R[:H-nUv M U(dUR [5v gg7fr^)r_rFr[rjrrr s rngraphsDataset.graphs> sTw.v6A ||'?? ?GG7**56 6sAAc#># [[U] U5H9up#pEURUR:Xa X#US4v M)X#XER4v M; g7frr)r_rFrrjr)rhquadrrrrrms rnr Dataset.quadsI sQ 4T:JA!||t111Atm#A||++ ;sAAc$URS5$)z$Iterates over all quads in the storerg)rrss rnrDataset.__iter__U szz233rpc grrrrs rnrDataset.serialize[ rrpc grrrrs rnrrf rrpc grrrrs rnrrr rrpc grrrrs rnrr} rrpc grrrrs rnrr rrpc 2>[[U] "SXX4S.UD6$)N)rrr\rr)r_rFr)rhrrr\rrrms rnrr s+Wd- # TX  rp)rwrrZrjri)rKFN)rir7rZrWrr[r:)rz(Tuple[Type[Dataset], Tuple[Store, bool]])r8Tuple[Store, _ContextIdentifierType, _ContextType, bool])rrrr1)rhrErr>rrEri)rj:Optional[Union[_ContextIdentifierType, _ContextType, str]]r\r[rrAr])rr_rr[rr[rr[rr`rrarrrrF)rrrrA)rhrErrrrErrr)rrr2Generator[_OptionalIdentifiedQuadType, None, None])rrrVrWrXrYrZr[)NtrigNN)rrjrkrlrmr`rorrprrjrrrrrrrrrr[r rrrrrsrtrus@rnrFrF sWv$-#,0 + ++* ++$%%&&%%&&//7>STMT TRV"N  F "& $"&26,0: :  :  : :0:*:: :xK   V   /3 7+ 7 , 7 7 /37+7 ,77:> ,6 , ; , ,4 ;4        !      !       !"% <      JM!"% 'F'' '  '  ' "''JN""&  F           "   rpcn^\rSrSrSrS U4SjjrS SjrS SjrS SSjjrSSjr SSjr S r U=r $)rHi a 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. c,>[[U] X5 grr)r_rHr`)rhrirjrms rnr`QuotedGraph.__init__ s k4)%# UHQupp4[U[5(dMURTRLdM8[XU5(dMKXX44v MS g7frr)rbrHrjrrs rnr#QuotedGraph.addN.. sT # a![)  / A!$ Q1L#rrrs` rnrQuotedGraph.addN s)  #   rpc:SURRUS9-$)rz{%s}rrrs rnrQuotedGraph.n3 rrpcURR5nURRRnSnX1U4-$)NzK{this rdflib.identifier %s;rdflib:storage [a rdflib:Store;rdfs:label '%s']})rjrrirmr)rhrjlabelrs rnrQuotedGraph.__str__ sC__'')  $$-- 0 e,,,rpc>[URUR44$rr)rHrirjrss rnrQuotedGraph.__reduce__ sTZZ999rpr)rir7rjr8r<r=rrrer:rf) rrjrkrlrmr`rrrrrrsrtrus@rnrHrH s?= =A= P-::rprH cJ\rSrSrSrS SjrS SjrS SjrS SjrSSjr Sr g )rIi aWrapper 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. Args: 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! c<U [5=o0l[[[5S-5nUR U5HJupVUR U5(dM[URUS55nURXv45 ML UR5 g)N_r) r _listr/rrr startswithrFr~rsort)rhrr$r3LI_INDEXrris rnr` Seq.__init__ sw !V# #c(S.)++G4DA||H%% (B/0 aV$ 5  rpcU$rrrrss rnr Seq.toPython rrpc#># URH upUv M g7f)z#Generator over the items in the SeqNr3)rhr2rs rnr Seq.__iter__ szzGAJ"sc,[UR5$)zLength of the Seq)rr3rss rnr Seq.__len__ s4::rpc@URRU5upU$)z Item given by index from the Seq)r3r)rhindexrs rnrSeq.__getitem__ sjj,,U3  rpr<N)rrAr$r2)rrI)rrKrE)rr4) rrjrkrlrmr`rrrrrsrrprnrIrI s    rprIc(\rSrSrSSjrSSjrSrg)rJi cgrrrrss rnr`ModificationException.__init__  rpcg)NzZModifications and transactional operations not allowed on ReadOnlyGraphAggregate instancesrrss rnrModificationException.__str__ s  / rprNrr1r:rrjrkrlr`rrsrrprnrJrJ s   rprJc(\rSrSrSSjrSSjrSrg)rKi cgrrrrss rnr`&UnSupportedAggregateOperation.__init__ rFrpcg)NzCThis operation is not supported by ReadOnlyGraphAggregate instancesrrss rnr%UnSupportedAggregateOperation.__str__ sWrprNrIr:rJrrprnrKrK s  XrprKc^\rSrSrSrS"S#U4SjjjrS$SjrS%SjrS&SjrS&Sjr S'S(Sjjr S)S jr S*S jr S+S jr S*S jr\S,S j5r\S-Sj5r\S.Sj5rS.SjrS/SjrS0SjrS1SjrS&SjrS1SjrS2SjrS2SjrS3S4SjjrS5SjrS6S7SjjrS6S8SjjrS9SjrS:S;SjjrS<S=SjjrS3S>SjjrS&S jr S!r!U=r"$)?rLi zUtility 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. c$>Ub/[[U] U5 [RX5 SUl[ U[ 5(a6U(a/UVs/sHn[ U[5(dMUPM sn(dS5eXlgs snf)Nz*graphs argument must be a list of Graphs!!)r_rLr`rA*_ReadOnlyGraphAggregate__namespace_managerrbr r )rhr rirrms rnr`ReadOnlyGraphAggregate.__init__& sz   ($ 8 ? NN4 ''+D $ vt $ $";FqjE&:F; 8 8  8 < )rr rss rnr}ReadOnlyGraphAggregate.__repr__3 s4s4;;7GGGrpc[5errrJrs rnrReadOnlyGraphAggregate.destroy6 #%%rpc[5errrWrss rnrReadOnlyGraphAggregate.commit: rYrpc[5errrWrss rnrReadOnlyGraphAggregate.rollback= rYrpcNURHnURXU5 M grr)r r)rhrrrs rnrReadOnlyGraphAggregate.open@ s [[E JJtF 3 !rpcJURHnUR5 M grr)r r)rhrs rnrReadOnlyGraphAggregate.closeI s[[E KKM!rpc[5errrWrs rnrReadOnlyGraphAggregate.addM rYrpc[5errrWrs rnrReadOnlyGraphAggregate.addNP rYrpc[5errrWrs rnrReadOnlyGraphAggregate.removeT rYrpcgrrrrs rnrReadOnlyGraphAggregate.triplesX rrpcgrrrrs rnrri^ rrpcgrrrrs rnrrid rrpc## Uup#nURH^n[U[5(a#URXU5H up$X#U4v M M;UR X#U45H upgnXgU4v M M` g7frr)r rbr$rr) rhrrrrrrrrs rnrrij sra[[E!T""FF4A.DA'M/#(--q ":JBB"*$#; !sA5A7cSn[U5S:XaUSnURH-nUbURUR:XdM"USSU;dM- g g)NrrTF)rr rj)rhrrrs rnr#ReadOnlyGraphAggregate.__contains__w s[ ~ ! #$Q'G[[E%"2"2g6H6H"H!"1%.!rpc#^# Sn[U5S:XaUup4pROUup4nUbOURVs/sH ofU:XdM UPM snH&nURX4U45H upn XX4v M M( gURH&nURX4U45H upn XX4v M M( gs snf7f)z8Iterate over all the quads in the entire aggregate graphNr)rr r) rhrrrrrrrrrrs rnrReadOnlyGraphAggregate.quads s  ~ ! #'JA!Q%GA! =%)[[;[F![;"'--q ":JBB"++#;<"'--q ":JBB"++#;% . s/;a3q66;s)sumr rss rnrReadOnlyGraphAggregate.__len__ s/4;;///rpc[5errrKrss rnrReadOnlyGraphAggregate.__hash__ +--rpcUcg[U[5(ag[U[5(a3URUR:URUR:- $g)Nr)rbrArLr rs rnrReadOnlyGraphAggregate.__cmp__ sP = u % % 5 6 6KK%,,.4;;3MN Nrpc[5errrWrs rnrReadOnlyGraphAggregate.__iadd__ rYrpc[5errrWrs rnr ReadOnlyGraphAggregate.__isub__ rYrpc## Uup4nURH(nURX4U45nUH upn XU 4v M M* g7frr)r rG) rhrrr$r%r&rchoicesrrrs rnrG&ReadOnlyGraphAggregate.triples_choices sM '-#G[[E++W,IJG"aAg # !s?Ac[US5(a,UR(aURRU5$[5eNrk)rrkrtrKrus rnrtReadOnlyGraphAggregate.qname s8 4, - -$2H2H))//4 4+--rpc[US5(a,UR(aURRX5$[5er)rrkrxrKrys rnrx$ReadOnlyGraphAggregate.compute_qname s8 4, - -$2H2H))77F F+--rpc[5errrw)rhrrr}s rnrReadOnlyGraphAggregate.bind s ,--rpc## [US5(a)URR5H upX4v M gURH!nUR5H upX4v M M# g7fr)rrkrr )rhrrrs rnr!ReadOnlyGraphAggregate.namespaces sh 4, - -%)%;%;%F%F%H!''&I).)9)9);%F ++*<%sA-A/c[5errrwrs rnr!ReadOnlyGraphAggregate.absolutize ryrpc [5errrW)rhrrrrs rnrReadOnlyGraphAggregate.parse s $%%rpc[5errrwrs rnrReadOnlyGraphAggregate.n3 ryrpc[5errrwrss rnr!ReadOnlyGraphAggregate.__reduce__ ryrp)r5r r)r z List[Graph]rizUnion[str, Store]r:)rrrr)rrr;)rzstr | tuple[str, str]rrWrr1rI)rrPrr)rr>rrr?rArCr)rrTrzbGenerator[Tuple[_SubjectType, Union[Path, _PredicateType], _ObjectType, _ContextType], None, None]rE)rhr@rrGrrrrrLrQrRrS)rr[rrr}rWrrrTrU)rrrrFrrri) rr_rr[rr[rrrr)rkr9rr)#rrjrkrlrmr`r}rrrrrrrrrrrrrrrrr rGrtrxrrrrrrrsrtrus@rnrLrL s  H&&&4&&&1"1 ,11 5&5 055 =#= 8== %# % 8 % ,7, ,20.&&+/ ! (  , . .GK.#.03.?C. . ,.#' $ &  &  &  & &  &...rprLcgrrrtermss rnrr s36rpcgrrrrs rnrr s&)rpcXUH$n[U[5(aMSU<S35e g)NzTerm rT)rbr-)rrs rnrr s* !T""K$KK" rpc`\rSrSrSrS S SjjrS SjrSSjrSSjrS Sjr SSjr S r g )rMi aWrapper around graph that turns batches of calls to Graph's add (and optionally, addN) into calls to batched calls to addN`. Args: graph: The graph to wrap batch_size: The maximum number of triples to buffer before passing to Graph's addN batch_addn: If True, then even calls to `addN` will be batched according to batch_size Attributes: graph: The wrapped graph count: The number of triples buffered since initialization or the last call to reset batch: The current buffer of triples cU(aUS:a [S5eXlU4UlX lX0lUR 5 g)Nryz$batch_size must be a positive number)r_r_BatchAddGraph__graph_tuple_BatchAddGraph__batch_size_BatchAddGraph__batch_addnreset)rhr batch_size batch_addns rnr`BatchAddGraph.__init__ s;Z!^CD D #X&& rpc"/UlSUlU$)zA Manually clear the buffered triples and reset the count to zero r)batchcountrss rnrBatchAddGraph.reset s')   rpct[UR5UR:a,URR UR5 /UlU=R S- sl[U5S:Xa)URR XR-5 U$URR U5 U$)zzAdd a triple to the buffer. Args: triple_or_quad: The triple or quad to add Returns: The BatchAddGraph instance rr)rrrrrrrr)rhrs rnrBatchAddGraph.add s tzz?d// / JJOODJJ 'DJ a ~ ! # JJ  n/A/AA B  JJ  n - rpcUR(aUHnURU5 M U$URRU5 U$rr)rrrr)rhrqs rnrBatchAddGraph.addN; s>      JJOOE " rpc&UR5 U$rr)rrss rn __enter__BatchAddGraph.__enter__C s  rpc\USc&URRUR5 gg)Nr)rrr)rhexcs rn__exit__BatchAddGraph.__exit__G s$ q6> JJOODJJ ' rp) __batch_addn __batch_size __graph_tuplerrrN)iF)rrArrFrrW)rrM)rzUnion[_TripleType, _QuadType]rrM)rr>rrMrI) rrjrkrlrmr`rrrrrrsrrprnrMrM s9    6(rprM)rr-rzte.Literal[True])rrrrW)zrm __future__rloggingrrr}iortypingrrrrr r r r r rrrrrrrrrrr urllib.parserurllib.requestrrdflib.exceptionsrVrdflib.namespacer rdflib.pluginrc rdflib.queryr rdflib.utilrrdflib.collectionrrrrr rdflib.parserr!r"r# rdflib.pathsr$rdflib.resourcer%rdflib.serializerr& rdflib.storer'rr(r)r*r+r,r-r.r/typing_extensionsterdflib.plugins.sparql.sparqlr0r1r2r3r4r8r6rOr7rPrNr9r;r:r<rSrRr=r>rTr?rQrMr@rCrErdflib._type_checkingrG getLoggerrr+__all__rUrAr5rDrrFrHterm _ORDERINGrIrrJrKrLrrMrrprnrsJX# ,"'&$()==BB$(   ":  'CD Q R $mXn5MM""DE#$mX>V5WW ^h'78(=:QQx7x ?VVW ^  ] ^  ^ ] ^ !!IJ$%UV ^ U+ ,- ]  ^ U+ ,- ] ^ ""LMm;< @A $| h~68M MN (< $~"68M MN (< (>":D