PiPdZddlmZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*Z+ddl,m-Z-dd l"m.Z.dd l$m/Z/m0Z0m1Z1dd l2m3Z3m4Z4m5Z5dd l6m7Z7dd l8m9Z9ddl:m;Z;ddlm?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFe rddlGZHddl(Z+ddlImJZJmKZKeDZLeDZMeDZNeAZOedZPedZQedddedfZRedZSedddedfZTeedededfZUeede7edfZVeededededfZWeede7ededfZXedZYedZZeedeededfZ[eedeedededfZ\edZ]ede7dfZ^edZ_eeeeLeeMeeNfeeeLeeMeeNfeeeLeeMeeNffZ`edd !Zaed"d#!Zbed$d%!ZceCsJe0sJe rdd&ldmeZeejfegZhgd'Zied(ZjGd)d eDZkekZlGd*d#ekZmeFd+ZnGd,d%emZoGd-d.ekZpd/e+jqjrep<Gd0d1ZsGd2d3etZuGd4d5etZvGd6d7emZwedCd<ZxedDd?ZxdDd@ZxGdAdBZydS)Eak$ 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|eZdZUdZded<ded<ded<ded< ddfd ZeddZeddZeddZ e j ddZ ddZ dd Z dd#Z dd%Zdd&Zdd'Z ddd,Zddd.Zdd1Zdd4Zdd6Zedd8Zedd;Zedd>Zdd?Zd@ZddBZddCZddDZddEZddFZddGZddHZddJZ ddKZ!ddLZ"ddNZ#ddOZ$ddPZ%ddQZ&ddRZ'ddSZ(e%Z)e&Z*ddUZ+ ddd\Z, dddaZ- ddddZ. dd dfZ/ dd dhZ0 dd djZ1 d d dnZ2e dddrZ3e dddsZ3e ddduZ3e dddvZ3d e4j3d d dwfddxZ3dd|Z5 d ddZ6 d ddZ7 d ddZ8ddZ9dddZ: dddZ;ddZ<dddZ=eddZ>e d ddZ>e d!d"dZ>e d d#dZ>e d!d$dZ> d%d&dZ> d'd(dZ? d)d*dZ@ d+d,dDŽZA d-d.d˄ZBd d/d̄ZCd0d΄ZDddτZEddЄZFd1d҄ZGd2dՄZHd3d؄ZId4dۄZJ d5d6dZK d7d8dZLd dd9dZMxZNS(:rAa 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]basedefaultNrdflibstoreUnion[Store, str] identifier,Optional[Union[_ContextIdentifierType, str]]namespace_managerOptional[NamespaceManager]bind_namespacesrGctt|||_||p t |_t |jtst|j|_|t |ts*tj |tx|_ }n||_ ||_ ||_d|_d|_d|_dSNF)superrA__init__r\r(_Graph__identifier isinstancer*r/r'pluginget _Graph__store_Graph__namespace_manager_bind_namespacesrXrYrZ)selfr_rarcr\re __class__s `/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/rdflib/graph.pyrizGraph.__init__s eT##%%%  1&1%''$+^<< : &t'8 9 9D  %'' !#;6:eU#;#;#=#= =DL55 DL#4 /"""returnr'c|jSN)rnrqs rsr_z Graph.store"s |rtr8c|jSrw)rjrxs rsrazGraph.identifier&s   rtr cR|jt||j|_|jS)z0 this graph's namespace-manager )ror rprxs rsrczGraph.namespace_manager*s+  # +'7d>S'T'TD $''rtnmNonec||_dSrw)ro)rqr{s rsrczGraph.namespace_manager3s#%   rtstrc8d|jdt|dS)Nz)ratyperxs rs__repr__zGraph.__repr__7s/3T KKrtct|jtr.|jd|jjjdSd|jjjzS)Nz9 a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'z'].z?[a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label '%s']].)rkrar/n3r_rr__name__rxs rs__str__z Graph.__str__:sf dov . . .##%%%%tz';'D'D'DF F W $-. .rtrqr@c|Srwrxs rstoPythonzGraph.toPythonD rt configurationc:|j||S)zzGraph.addN..|sx  1a!U##  //Aq!$$01aL0///   rt)rnaddNrqrs` rsrz Graph.addNysL     #       rtr9c>|j|||S)zRemove a triple from the graph If the triple does not provide a context attribute, removes the triple from all contexts. context)rnremoverqrs rsrz Graph.removes$ FD111 rt"Generator[_TripleType, None, None]cdSrwrrs rstriplesz Graph.triples .1Srtr;&Generator[_TriplePathType, None, None]cdSrwrrs rsrz Graph.triples 25rtr=.Generator[_TripleOrTriplePathType, None, None]cdSrwrrs rsrz Graph.triples :=rtc#K|\}}}t|tr&||||D] \}}|||fV dS|j|||f|D]\\}}}}|||fVdS)aGenerator 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)rkr$evalrnr) rqrrrr_s_o_pcgs rsrz Graph.tripless 1a a   !&&q!,,  B!Ri  %)L$8$8!QD$8$Q$Q ! ! Rb"bj     ! !rtcFt|tr|j|j|j}}}|||||||fS||||S||||S||||S|| ||S|| ||S|| ||S|||f|vSt|ttfr||Std)ah 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" NzWYou can only index a graph by a single rdflib term or path, or a slice of rdflib terms.)rkslicestartstopsteprsubject_predicatessubject_objectspredicate_objectssubjects predicatesobjectsr$r- TypeError)rqitemrrrs rs __getitem__zGraph.__getitem__sKF dE " "% j$)TY!qAyQY19||Q1I...qy..q111qy++A...qy--a000}}Q***q!,,,||Aq)))1ayD(( tTl + + ))$// /i rtintc8|j|S)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)rn__len__rxs rsrz Graph.__len__s|##D#111rtc,|dS)z}Iterates over all triples in the store. Returns: A generator yielding all triples in the store. NNNrrxs rs__iter__zGraph.__iter__s ||.///rtc:||D]}dSdS)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 rs __contains__zGraph.__contains__s+ll6**  F44urtc*t|jSrw)hashrarxs rs__hash__zGraph.__hash__#sDO$$$rtcz|dSt|tr!|j|jk|j|jkz SdS)NrkrArarqothers rs__cmp__z Graph.__cmp__&sI =2 u % % Oe&66%"22 1rtcLt|to|j|jkSrwrrs rs__eq__z Graph.__eq__3s!%''ODOu?O,OOrtcT|dup$t|to|j|jkSrwrrs rs__lt__z Graph.__lt__6s/  ue $ $ K5;K)K rtrc||kp||kSrwrrs rs__le__z Graph.__le__;e|,tu},rtcTt|tr|j|jkp|duSrwrrs rs__gt__z Graph.__gt__>s05%((OT_u?O-O   rtc||kp||kSrwrrs rs__ge__z Graph.__ge__CrrtIterable[_TripleType]cJfd|DS)zKAdd all triples in Graph other to Graph. BNode IDs are not changed.c3,K|]\}}}|||fVdSrwr)rrrrrqs rsrz!Graph.__iadd__..Is177gaA1aD/777777rtrrs` rs__iadd__zGraph.__iadd__Fs1 7777777777 rtc:|D]}|||S)zRSubtract all triples in Graph other from Graph. BNode IDs are not changed.)r)rqrrs rs__isub__zGraph.__isub__Ls-  F KK     rtc t|}n#t$rt}YnwxYwtt |t |zD]\}}||||D]}|||D]}|||S)z6Set-theoretic union BNode IDs are not changed.)rrrAsetlist namespacesbindr)rqrretvalprefixurixys rs__add__z Graph.__add__Ss T$ZZ\\FF   WWFFF tDOO$5$566e>N>N>P>P9Q9QQRR % %KFC KK $ $ $ $  A JJqMMMM  A JJqMMMM 55c t|}n#t$rt}YnwxYw|D]}||vr|||S)z>Set-theoretic intersection. BNode IDs are not changed.rrrArrqrrrs rs__mul__z Graph.__mul__bso T$ZZ\\FF   WWFFF   ADyy 1  rc t|}n#t$rt}YnwxYw|D]}||vr|||S)zs 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)rqrsubject predicateobject_s rsrz Graph.setsw)/%)W    K    ! ! K " ! ! Wi./// '9g./// rtr!Union[None, Path, _PredicateType]object/Optional[Union[_ObjectType, List[_ObjectType]]]unique#Generator[_SubjectType, None, None]c#Kt|tr%|D] }||||D]}|V!dS|s%|d||fD] \}}}|V dSt }|d||fD]U\}}}||vrK|V ||%#t $r#} t| dd} ~ wwxYwVdS)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) rkrrrrr MemoryErrorloggererror) rqrrrobjrrrsubses rsrzGraph.subjectssY fd # # "  y#v>>AGGGG   "#||T9f,EFFGAq!GGGGuu#||T9f,EFF " "GAq!}}" HHQKKKK*""""LL#$ W W W" " % " "B// C9CCrOptional[_SubjectType]Optional[_ObjectType]%Generator[_PredicateType, None, None]c#PK|s%||d|fD] \}}}|V dSt}||d|fD]U\}}}||vrK|V ||%#t$r#}t|dd}~wwxYwVdS)asGenerate 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. Nrrrrrrr) rqrrrrrrpredsr s rsrzGraph.predicatess  <<$(?@@  1a  EEE<<$(?@@  1aE>>GGG ! &  SSS  "  sA55 B"?BB"1Optional[Union[_SubjectType, List[_SubjectType]]]"Generator[_ObjectType, None, None]c#Kt|tr%|D] }||||D]}|V!dS|s%|||dfD] \}}}|V dSt }|||dfD]U\}}}||vrK|V ||%#t $r#} t| dd} ~ wwxYwVdS)aA 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) rkrrrrrrrr) rqrrrsubjrrrobjsr s rsrz Graph.objectssY" gt $ $ "  dIv>>AGGGG   "#||Wi,FGGGAq!GGGGuu#||Wi,FGG " "GAq!}}" HHQKKKK*""""LL#$ W W W" " % " "r!:Generator[Tuple[_SubjectType, _PredicateType], None, None]c#`K|s'|dd|fD] \}}}||fV dSt}|dd|fD][\}}}||f|vrO||fV |||f+#t$r#}t|dd}~wwxYw\dS)z[A generator of (optionally unique) (subject, predicate) tuples for the given objectNrr&)rqrrrrr subj_predsr s rsrzGraph.subject_predicatess  <<tV(<==  1ad   J<<tV(<==  1aq6++Q$JJJ"1v....&  SSS  ,  %A== B*B%%B*7Generator[Tuple[_SubjectType, _ObjectType], None, None]c#`K|s'|d|dfD] \}}}||fV dSt}|d|dfD][\}}}||f|vrO||fV |||f+#t$r#}t|dd}~wwxYw\dS)z[A generator of (optionally unique) (subject, object) tuples for the given predicateNrr&)rqrrrrr subj_objsr s rsrzGraph.subject_objectss <<y$(?@@  1ad   I<<y$(?@@  1aq6**Q$JJJ! q!f----&  SSS  +  r09Generator[Tuple[_PredicateType, _ObjectType], None, None]c#`K|s'||ddfD] \}}}||fV dSt}||ddfD][\}}}||f|vrO||fV |||f+#t$r#}t|dd}~wwxYw\dS)z[A generator of (optionally unique) (predicate, object) tuples for the given subjectNrr&)rqrrrrr pred_objsr s rsrzGraph.predicate_objects-s  <<$(=>>  1ad   I<<$(=>>  1aq6**Q$JJJ! q!f----&  SSS  +  r0_TripleChoiceTyperOptional[_ContextType]c#vK|\}}}|j|||f|D]\\}}}} |||fVdS)Nr)r_triples_choices) rqrrrrrrrrrs rsr:zGraph.triples_choicesBso '-#G"Z77 i )48    MIQ1rQ'MMMM  rt.Optional[Node]anycdSrwrrqrrrr]r<s rsvaluez Graph.valueO srtcdSrwrr>s rsr?z Graph.valueYr@rtOptional[_PredicateType]cdSrwrr>s rsr?z Graph.valuecr@rtcdSrwrr>s rsr?z Graph.valuems rtTc |}||||||dS||||}||||}||||} t|}|dur t|d|d|d|d}|j|||fd} | D](\\} } } } |d| d| d| dt | d z })tj|#t$rYnwxYwn#t$r|}YnwxYw|S) a Get 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) ) rrrnextr_rr exceptionsUniquenessError StopIteration)rqrrrr]r<rvaluesmsgrrrrcontextss rsr?z Graph.valuews._!2FN!fn4 >\\'955F ?]]9f55F  __Wf55F &\\Fe||LLLL#77IIIvvv7 #j00'9f1MtTTG/6+ Aq8AAAAAA NNNN   %4S999$D#   FFF , s%C7.A8C&& C32C37 DDrr-Generator[Node, None, None]c#Kt|g}|rr||tj}||V||tj}||vrt d|||pdSdS)zwGenerator over all items in the resource specified by list Args: list: An RDF collection. Nz,List contains a recursive rdf:rest reference)rr?rfirstrest ValueErrorr)rqrchainrs rsitemsz Graph.itemss TF  ::dCI..D ::dCH--Du}} !OPPP IIdOOO     rtfunc-Callable[[_TCArgT, Graph], Iterable[_TCArgT]]argrUseenOptional[Dict[_TCArgT, int]]c#K|i}n||vrdSd||<|||D]$}|V||||D]}|V%dS)aGenerates 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)rqrUrWrXrtrt_2s rsr[zGraph.transitiveClosuresd <DD D[[ FS $sD//  BHHH..tR>>      rtremember+Optional[Dict[Optional[_SubjectType], int]]-Generator[Optional[_SubjectType], None, None]c#K|i}||vrdSd||<|V|||D] }||||D]}|V!dS)aTransitively 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)rqrrr^rrs rsrbzGraph.transitive_objectss  H h   F ll7I66  F,,VYII     rt*Optional[Dict[Optional[_ObjectType], int]],Generator[Optional[_ObjectType], None, None]c#K|i}||vrdSd||<|V|||D] }||||D]}|V!dS)aTransitively 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)rqrrr^rrs rsrfzGraph.transitive_subjectss  H X   F }}Y77  G--i(KK     rtrc6|j|Srw)rcqnamerqrs rsrhz Graph.qname9s%++C000rtgenerateTuple[str, URIRef, str]c8|j||Srw)rc compute_qnamerqrrjs rsrmzGraph.compute_qname<s%33CBBBrtr namespaceroverridereplacec>|j||||S)a\Bind 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/") ``` )rprq)rcr)rqrrorprqs rsrz Graph.bind?s.@%** I'+   rt)Generator[Tuple[str, URIRef], None, None]c#TK|jD] \}}||fV dS)zGenerator over all the prefix, namespace tuples Returns: Generator yielding prefix, namespace tuples N)rcr)rqrros rsrzGraph.namespacescsI "&!7!B!B!D!D $ $ FI)# # # # # $ $rtrdefragr/c8|j||S)z5Turn uri into an absolute URI if it's not one already)rc absolutizerqrrus rsrwzGraph.absolutizels%00f===rt destinationformatencodingargsbytesc dSrwrrqryrzr\r{r|s rs serializezGraph.serializeq rtc dSrwrrs rsrzGraph.serialize| rtc dSrwrrs rsrzGraph.serialize crt'Union[str, pathlib.PurePath, IO[bytes]]c dSrwrrs rsrzGraph.serializerrt1Optional[Union[str, pathlib.PurePath, IO[bytes]]]Union[bytes, str, Graph]c dSrwrrs rsrzGraph.serialize $'3rtturtleUnion[bytes, str, _GraphT]c >||j}tj|t|}|mt }|8|j|f|dd||dS|j|f||d||St|dr2ttt|}|j|f||d|nt|tjrt|}n\tt|} t!| \} } } } }}| dkr)| dkrt#d| dt%| }n| }t'|d 5}|j|f||d|dddn #1swxYwY|S) aSerialize 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\r{writefilez the file URI z2 has an authority component which is not supportedwb)r\rlrmr&rrgetvaluedecodehasattrrrr}rkpathlibPurePathr~rrRrr)rqryrzr\r{r| serializerstreamos_pathlocationschemenetlocpathparams_queryfragments rsrzGraph.serializes.B <9D3VZ 33D99  YYF$ $VQ$QQDQQQ((//888$ $VR$RRTRRR((( ; ( ( S"U)[11F J  NdX N N N N N N+w'788 'k**[11AI(ASAS>ffhV##||(jHjjj+400GG&Ggt$$ S$ $VR$RRTRRR S S S S S S S S S S S S S S S s4FFFroutOptional[TextIO]c|t|d||||ddS)N)rzr{T)rflush)printrr)rqrzr{rs rsrz Graph.printsN  NN4N B B I I( S S      rtsourceMOptional[Union[IO[bytes], TextIO, InputSource, str, bytes, pathlib.PurePath]]publicIDrr!Optional[Union[BinaryIO, TextIO]]dataOptional[Union[str, bytes]]c bt||||||}||j}d}|tt|dr^t|jddrHt |jjtr)tj |jj}|d}d} tj |t} n}#tj$rktj t |ts|nt|}|tj |t} YnwxYw | j||fi|n(#t"$r} |rt%d|z| d} ~ wwxYw |jr|n!#|jr|wwxYw|S) a9Parse 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. rrrrrrzNFrnamerTzCould 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_typergetattrrrkrr~r^util guess_formatrlrmr"PluginExceptionr!parse SyntaxErrorr auto_closer) rqrrrzrrrr|could_not_guess_formatparserses rsrz Graph.parses D%     >(F!& >'' DFK66 Dv{/55 D  11&+2BCC~!)-& 2/VZ//11FF% 2 2 2[--(==N3v;;F~/VZ//11FFF 2  FL . . . . . .   % !S   /        s="B;;A7D54D59E F E.E))E..FF,sparql query_objectUnion[str, Query] processorUnion[str, query.Processor]resultUnion[str, Type[query.Result]]initNsOptional[Mapping[str, Any]] initBindings"Optional[Mapping[str, Identifier]]use_store_providedkwargs query.Resultc |pi}|p t|}|jrd}n)t|tr |jj}n|j}t|jdr)|r' |jj ||||fi|S#t$rYnwxYwt|tj s2tj tt|tj }t|tjs(tj |tj|}||j |||fi|S)ai 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)dictrrZrkrDdefault_contextrarr_rNotImplementedErrorResultrlrmrr~ Processor) rqrrrrrrr query_graphs rsrz Graph.queryskP$)r 24 1 122   *%KK . / / *.9KK/K 4:w ' ' ,>  'tz'     '    &%,// AZS& 1 15<@@F)U_55 E> 9eo>>tDDIvoiolL&SSFSSTTT3B BB update_objectUnion[Update, str](Union[str, rdflib.query.UpdateProcessor]c |pi}|p t|}|jrd}n)t|tr |jj}n|j}t|jdr)|r' |jj ||||fi|S#t$rYnwxYwt|tj s(tj|tj |}|j |||fi|S)aeUpdate 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)rrrZrkrDrrarr_rrrUpdateProcessorrlrm)rqrrrrrrrs rsrz Graph.updates/>$)r 24 1 122   *%KK . / / *.9KK/K 4:x ( ( -?  (tz(!    '    )U%:;; KD 9e.CDDTJJIy |VNNvNNNrc>d|j|zS)%Return an n3 identifier for the Graphz[%s]rcrarrqrcs rsrzGraph.n3 !**=N*OOOOrt8Tuple[Type[Graph], Tuple[Store, _ContextIdentifierType]]c,t|j|jffSrw)rAr_rarxs rs __reduce__zGraph.__reduce__s     rtc>t|t|krdS|D]:\}}}t|tst|ts |||f|vrdS;|D]:\}}}t|tst|ts |||f|vrdS;dS)aCheck 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)lenrkr()rqrrrrs rs isomorphiczGraph.isomorphics" t99E " "5 ! !GAq!a'' ! 1e0D0D !1ayE)) 55 ! !GAq!a'' ! 1e0D0D !1ayD(( 55trtc"t|}g}|sdS|tjt |g}|r|}||vr||||D]}||vr||vr|| ||D]}||vr||vr|| |t |t |krdSdS)aCheck 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)rT) r all_nodesrandom randrangerpopappendrr)rqr discoveredvisitingrnew_xs rs connectedzGraph.connected5s8))**   5f.s9~~>>?@ + A ""!!!$$$a00 + + **uH/D/DOOE***a00 + + **uH/D/DOOE*** + y>>S__ , ,45rt Set[Node]ct|}|||Srw)rrrr)rqress rsrzGraph.all_nodes^s6$,,..!! 4==??### rtr2rc"t||S)aACreate 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) ] ``` rrqras rs collectionzGraph.collectioncs,$ +++rtUnion[Node, str]r%cjt|tst|}t||S)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 ``` )rkr-r/r%rs rsresourcezGraph.resource{s3(*d++ , ++Jj)))rttarget$Callable[[_TripleType], _TripleType]cr|dD] }|||!dS)Nr)rr)rqrrUts rs_process_skolem_tupleszGraph._process_skolem_tuplessG011  A JJttAww      rt new_graphOptional[Graph]bnodeOptional[BNode] authoritybasepathcd fd d fd }|tn|}|||n/ttr||fd|S) Nrr(rr6ruc|\}}}||kr5trt|tsJ|}||kr5trt|tsJ|}|||fSN)rr)rrkr( skolemize)rrrrrrrs rs do_skolemizez%Graph.skolemize..do_skolemizesIQ1Ezz 0%a/////KK)hKGGEzz 0%a/////KK)hKGGa7Nrtc|\}}}t|tr|}t|tr|}|||fSr)rkr(r)rrrrrrs rs do_skolemize2z&Graph.skolemize..do_skolemize2siIQ1!U## HKK)hKGG!U## HKK)hKGGa7Nrtc|Srwr)rrrs rsz!Graph.skolemize..s,,ua:P:Prt)rr(rr6rur6rr6rur6)rArrkr()rqrrrrr rrs ``` @rsrzGraph.skolemizes              &-9 =  ' ' > > > > u % % R  ' '0P0P0P0P0P Q Q Q rturirefOptional[URIRef]cd dd d}|tn|}|||n/ttr||fd|S) Nrr/rr6ruc|\}}}||kr2trt|tsJ|}||kr2trt|tsJ|}|||fSrw)rrkr/ de_skolemize)rrrrrs rsdo_de_skolemizez+Graph.de_skolemize..do_de_skolemizesIQ1F{{ 1%a00000NN$$F{{ 1%a00000NN$$a7Nrtc|\}}}tj|r"t|}n5tj|r!t|}t |t rktj|r"t|}n5tj|r!t|}|||fSrw)r._is_rdflib_skolemrr)_is_external_skolemrkr/)rrrrs rsdo_de_skolemize2z,Graph.de_skolemize..do_de_skolemize2sIQ1,Q// ,NN//11*1-- ,!HH))++!V$$ 00330#A3355AA.q110a--//Aa7Nrtc|Srwr)rrrs rsr z$Graph.de_skolemize..s//&RS:T:Trt)rr/rr6rur6r )rArrkr))rqrrrrrs ` @rsrzGraph.de_skolemizes        $&-9 >  ' '0@ A A A A  & & V  ' '0T0T0T0T0T U U U rt) target_graphrrcX|tn|dfd |S)aRetrieves 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. 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. See: Nrr2rur|c|ddfD]F\}}} |||ft|tur|ddf vr |Gdtj|fD]=\}}}|ddfD]\}}} |||f>dSrw)rrrr(rr) rrrrs2p2o2 add_to_cbdrqsubgraphs rsrzGraph.cbd..add_to_cbds<<dD(9:: " "1a aAY'''77e##D$x(G(GJqMMM <<s{C(@AA / /1a"&,,4"?"?//JBBLL"b"..../ / /rt)rr2rur|)rA)rqrrrr s` @@rscbdz Graph.cbds]J  wwHH#H / / / / / / / /$  8rt)r]NNNr^) r_r`rarbrcrdr\r[rerG)rur')rur8)rur )r{r rur|rur~)rqr@rur@)rqr@rr~rur@F)rrrrWrur)rrWrur|rqr@rr6rur@rqr@rrrur@)rqr@rr9rur@rr9rurrr;rurrr=rurrur)rur)rr=rurW)rurW)rrArurW)rqr@rrrur@)rrArurA)rqr@rrrur@)NNF)rrrrrrWrur)rr"rr#rrWrur$)rr(rrrrWrur)rg)rr#rrWrur-)rrrrWrur1)rr"rrWrur4rwrr7rr8rur).....) rr|rr|rr#r]r;r<rWrur|) rr"rr|rr|r]r;r<rWrur|) rr|rrBrr|r]r;r<rWrur|) rr"rrBrr#r]r;r<rWrur;)rr-rurN)rUrVrWrUrXrY)rr"rrBr^r_rur`)rrBrr#r^rcrurdrr~rur~Trr~rjrWrurk)TF) rr[rorrprWrqrWrur|rursr)rr~rurrur/ ryr|rzr~r\r[r{r~r|rrur}....... ryr|rzr~r\r[r{r|r|rrur~ ryrrzr~r\r[r{r[r|rrurA ryrrzr~r\r[r{r[r|rrur)NrNN)rqr@ryrrzr~r\r[r{r[r|rrur)rrN)rzr~r{r~rrrur|NNNNNNrrrr[rzr[rr[rrrrr|rrurA)rrNNT)rrrrrrrrrrrrWrrrur)rNNT)rrrrrrrrrrWrrrur|rcrdrur~rur)rur)rar2rur)rarrur%)rrArUrrur|NNNN) rrrrrr[rr[rurANN)rrrrrurA)rr2rrrurA)Or __module__ __qualname____doc____annotations__ripropertyr_rarcsetterrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r__or____and__rrrrrrrr:r?rrTr[rbrfrhrmrrrwrrrrrrrrrrrrrrrr! __classcell__rrs@rsrArAs IIV$-CG8<"/7 #######4X!!!X!(((X(&&&&LLLL....   JO88888YYYYY    111X1 555X5 ===X= !!!!0HHHT 2 2 2 20000    %%%%    PPPP    ----    ----             //// FG*8>>>> X ! X ! X!"% XJM!"% ''''X'JN""& AAAAAJ $      "& $"&26,0RRRRRn2:19.2;?#'CUCUCUCUCUP?G.2;?#' 8O8O8O8O8OtPPPPP    <''''R ,,,,0****0    &*!%#'"& #####LMQ)))))XJN>>>>>>>>>>rtcTeZdZUdZded< dgdhfd Zed ZejdZdidZ e djdkdZ e djdldZ e djdmdZ e djdndZ e djdod"Z e djdpd$Z djdpd%Z dqd&Z drd*Z e dsd.Ze dtd/Zdud2Zdvd5Zdrd6Ze dwdxd<Ze dwdyd?Ze dwdzdAZ d{dzdBZ d{d|dDZ d{d}dGZd~dIZ d{ddLZddOZ dddSZddTZd{ddXZ ddddZddfZxZS)rDa9A 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_contextr]Nr_r`ra$Optional[Union[IdentifiedNode, str]]default_graph_baser[c\tt|||t|turt jdt d|jjs Jdd|_d|_ t|j|p t||_ dS)Nraz4ConjunctiveGraph is deprecated, use Dataset instead. stacklevelz9ConjunctiveGraph must be backed by a context aware store.Tr_rar\) rhrDrirwarningswarnDeprecationWarningr_rXrZrAr(rG)rqr_rarIrrs rsrizConjunctiveGraph.__init__@s %%..u.LLL ::) ) ) MF"     z'  J  '"!.3*)>uwwEW/ / / rtc|jSrwrGrxs rsrz ConjunctiveGraph.default_contextX $$rtc||_dSrwrTrqr?s rsrz ConjunctiveGraph.default_context\ %rtrur~c.d}||jjjzS)NzK[a rdflib:ConjunctiveGraph;rdflib:storage [a rdflib:Store;rdfs:label '%s']]r_rrrrqpatterns rsrzConjunctiveGraph.__str__`s! 0 -666rtFtriple_or_quadrOrWcdSrwrrqr]r]s rs_spoczConjunctiveGraph._spocgs Crt%Union[_TripleType, _OptionalQuadType]r7cdSrwrr_s rsr`zConjunctiveGraph._spocn  Crtr|(Tuple[None, None, None, Optional[Graph]]cdSrwrr_s rsr`zConjunctiveGraph._spocus 473rt"Optional[_TripleOrQuadPatternType]r:cdSrwrr_s rsr`zConjunctiveGraph._spoc|s 3rtrTr>cdSrwrr_s rsr`zConjunctiveGraph._spocrcrt#Optional[_TripleOrQuadSelectorType]cdSrwrr_s rsr`zConjunctiveGraph._spocrcrtc|ddd|r|jndfSt|dkr|r|jnd}|\}}}n/t|dkr|\}}}}||}||||fS)z_ helper method for having methods that support either triples or quads N)rr_graph)rqr]r]rrrrs rsr`zConjunctiveGraph._spocs  !$g&Od&:&:4P P ~  ! # #(/9$$TA&IQ11  A % %)LQ1a AA!Qzrtcx||\}}}}||||f|D]}dSdS)z)Support for 'triple/quad in graph' syntaxrTF)r`r)rqr]rrrrrs rsrzConjunctiveGraph.__contains__sLZZ// 1aq!Qi33  A44urtrqrCrPc||d\}}}}t||||j|||f|d|S)zlAdd a triple or quad to the store. if a triple is given it is added to the default context Tr]F)rr)r`rr_rrqr]rrrrs rsrzConjunctiveGraph.addsZZZZ== 1aAq! 1ay!E::: rtr)Union[Graph, _ContextIdentifierType, str]rAcdSrwrrqrs rsrnzConjunctiveGraph._graphsMPSrtcdSrwrrus rsrnzConjunctiveGraph._graphs'*srt3Optional[Union[Graph, _ContextIdentifierType, str]]rc\|dSt|ts||St|ttfr|S ||j}|Jn*#t$r||j}YnwxYw|||Srw) rkrA get_contextrFrD get_graphra IndexErrorr)rqrrns rsrnzConjunctiveGraph._graphs 94!U## ##A&& &!g'7899 <!^^AL99F!----!<<<!--al;;FFF<""" sA--$BBrrcTjfd|DS)z&Add a sequence of triples with contextc3vK|]3\}}}}t|||||||fV4dSrw)rrnrs rsrz(ConjunctiveGraph.addN..se  *4!Q1QPQSTAUAU 1dkk!nn %      rtr_rrs` rsrzConjunctiveGraph.addNsJ     8=       rtcx||\}}}}|j|||f||S)zRemoves 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)r`r_rrrs rsrzConjunctiveGraph.removesC ZZ// 1a 1a)Q/// rt.rSrr8rcdSrwrrqr]rs rsrzConjunctiveGraph.tripless .1SrtrRrcdSrwrrs rsrzConjunctiveGraph.tripless 25rtrcdSrwrrs rsrzConjunctiveGraph.tripless :=rtc#K||\}}}}||p|}|jr||jkrd}n ||j}t |t r*||}||||D] \}}|||fV dS|j|||f|D]\\}}}}|||fVdS)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. Nr) r`rnrZrrkr$rr_r)rqr]rrrrrrs rsrzConjunctiveGraph.triples s ZZ// 1a++gl++   /$.... a   w1--  1Ag   "&!3!3Q1Iw!3!O!O   Aq2Ag   rt(Generator[_OptionalQuadType, None, None]c#K||\}}}}|j|||f|D]\\}}}}|D] }||||fV dS)z:Iterate over all the quads in the entire conjunctive graphrN)r`r_r)rqr]rrrrrctxs rsrzConjunctiveGraph.quads% s ZZ// 1a!Z//Aq 1/EE # #MIQ1r # #Asl"""" # # #rtrr7c#K|\}}}||js|j}n||}|j|||f|D]\\}}}} |||fVdS)zz.ConjunctiveGraph.get_graph..X s%IIIaalj.H.H.H.H.Hrtr)rMrs `rsrzzConjunctiveGraph.get_graphV s*IIII4==??III!LLrtrbrr\c<t|j||j|S)zgReturn a context graph for the given identifier identifier must be a URIRef or BNode. )r_rarcr\)rAr_rc)rqrarr\s rsryzConjunctiveGraph.get_contextZ s,*!"4     rtc<|jd|dS)z(Removes the given context from the graphrN)r_r)rqrs rsremove_contextzConjunctiveGraph.remove_contextk s! ,g66666rtr context_idr/cd|ddd}|d}t||S)z URI#context#rrNz#context)r\)splitr/)rqrrs rsrzConjunctiveGraph.context_ido s8iiQ"  #Jjs++++rtrrrrzrrrrrr|rc `t||||||}|j}|j|f||d||S)aParse source adding the resulting triples to its own context (sub graph of this graph). See [`rdflib.graph.Graph.parse`][rdflib.graph.Graph.parse] for documentation on arguments. Args: source: The source to parse 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 into which the source was parsed. In the case of n3 it returns the root context. Note: If the source is in a format that does not support named graphs its triples will be added to the default graph (i.e. ConjunctiveGraph.default_context). !!! 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. ConjunctiveGraph.default_context). r)rrz)r#rr) rqrrrzrrrr|rs rsrzConjunctiveGraph.parsev s[l%    "& fGxGG$GGG rtrc,t|j|jffSrw)rDr_rarxs rsrzConjunctiveGraph.__reduce__ s$*do!>>>rt)r]NN)r_r`rarHrIr[r"r#)r]rOr]rWrurO)r]rar]rWrur7)r]r|r]rWrurd)r]rfr]rWrur:)r]rTr]rWrur>)r]rir]rWrur>r]rTrurW)rqrCr]rPrurC)rrsrurA)rr|rur|)rrwrur)rqrCrrrurC).)r]rSrr8rur)r]rRrr8rur)r]rTrr8rurrw)r]rfrurr*r)rrrur)rar8rur)FN)rarbrrWr\r[rurA)rr5rur|)rr~rr[rur/r6r7r9)rr<r=r>r?rir@rrArrr`rrrnrrrrr:rrMrzryrrrrrDrEs@rsrDrD-s #"""$-;?,0        0%%X%&&&7777X     X 7777X7 X     X     X *"PPPXP ***X*,    +.1111X1 +.5555X5 +.====X=+/BDH # # # # #+/"$$$$ /300000"MMMM"      "7777,,,,, "& $"&26,0IIIIIV????????rtzurn:x-rdflib:defaultceZdZdZ dLdMfd Zed Zejd ZedZejdZefdZ dNdZ dOdZ dPdZ dQdZ dRdZ dSdTd$Z dUdVd0ZdWd2ZdXd3Z dYdZfd7 Z dYdZfd8 Z dYd[fd< Zd\d=Zed]dAZe d^d]dCZe d_d`dDZe d^dadFZe d_dbdIZ dcdbfdK ZxZS)drFaj 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" r]FNr_r`rZrWrIr[ctt||d|jjst dt |jt||_||_ dS)N)r_raz.Dataset must be backed by a graph-aware store!rO) rhrFrir_ graph_aware ExceptionrADATASET_DEFAULT_GRAPH_IDrGrZ)rqr_rZrIrrs rsrizDataset.__init__b sw gt%%Ed%CCCz% NLMM M %*/#! ! !  +rtcHtjdtd|jSNzIDataset.default_context is deprecated, use Dataset.default_graph instead.rLrMrPrQrRrGrxs rsrzDataset.default_contextt s/ W     $$rtcLtjdtd||_dSrrrWs rsrzDataset.default_context} s4 W     !&rtc|jSrwrTrxs rs default_graphzDataset.default_graph rUrtc||_dSrwrTrWs rsrzDataset.default_graph rXrtcptjdtdtt|jS)NzHDataset.identifier is deprecated and will be removed in future versions.rLrM)rPrQrRrhrFra)rqrrs rsrazDataset.identifier s: V     Wd##..rtrur~c.d}||jjjzS)NzB[a rdflib:Dataset;rdflib:storage [a rdflib:Store;rdfs:label '%s']]rZr[s rsrzDataset.__str__ s S -666rt(Tuple[Type[Dataset], Tuple[Store, bool]]c<t||j|jffSrw)rr_rZrxs rsrzDataset.__reduce__ sT TZ);<==rt8Tuple[Store, _ContextIdentifierType, _ContextType, bool]c6|j|j|j|jfSrwr_rarrZrxs rs __getstate__zDataset.__getstate__ sz4?D,>@RRRrtstater|c<|\|_|_|_|_dSrwr)rqrs rs __setstate__zDataset.__setstate__ s$ OTK DOT%79K9K9KrtrqrErrcD|d|D|S)zMAdd all quads in Dataset other to Dataset. BNode IDs are not changed.c3,K|]\}}}}||||fVdSrwr)rrrrgs rsrz#Dataset.__iadd__.. s277:1aA1aA,777777rtrrs rsrzDataset.__iadd__ s* 77777777 rtra:Optional[Union[_ContextIdentifierType, _ContextType, str]]r\rAc|Cddlm}m}|d||zdt }||}||_|j ||S)Nr)_SKOLEM_DEFAULT_AUTHORITYrdflib_skolem_genidgenidF)rp) rdflib.termrrrr(rrnr\r_ add_graph)rqrar\rrrs rsgraphz Dataset.graph s   R R R R R R R R II),??     **,,J KK # # Qrtrrrrzrrrrrr|rc 6tj|||||||fi||S)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)rqrrrzrrrr|s rsrz Dataset.parse s=n  &(FHdD  DH    rtrc,||S)zalias of graph for consistency)rrqrs rsrzDataset.add_graph szz!}}rtct|ts||}|j|| ||jkr|j|j|Srw)rkrAryr_ remove_graphrrrs rsrzDataset.remove_graph sq!U## $  ##A """ 9T/// J !3 4 4 4 rtrrrc# Ktjdtdd}tt||D]}||jtkz}|V|s|tVdSdS)Nz;Dataset.contexts is deprecated, use Dataset.graphs instead.rLrMF) rPrQrRrhrFrMrarrrqrr]rrrs rsrMzDataset.contexts s  I     w%%..v66  A q|'?? ?GGGGG 7**566 6 6 6 6 6 7 7rtc#Kd}tt||D]}||jtkz}|V|s|tVdSdSrg)rhrFrMrarrrs rsgraphszDataset.graphs% sw%%..v66  A q|'?? ?GGGGG 7**566 6 6 6 6 6 7 7rtquadrf2Generator[_OptionalIdentifiedQuadType, None, None]c#Ktt||D]-\}}}}|j|jkr |||dfV ||||jfV.dSrw)rhrFrrar)rqrrrrrrrs rsrz Dataset.quads0 s ..44T:: , ,JAq!Q|t111Atm####Aq|+++++  , ,rtc,|dS)z$Iterates over all quads in the storer:)rrxs rsrzDataset.__iter__< szz2333rtryr{r}c dSrwrrs rsrzDataset.serializeB rrt.c dSrwrrs rsrzDataset.serializeM rrtc dSrwrrs rsrzDataset.serializeY rrtrc dSrwrrs rsrzDataset.serialized rrtrrc dSrwrrs rsrzDataset.serializeo rrttrigc Ntt|jd||||d|S)N)ryrzr\r{r)rhrFr)rqryrzr\r{r|rrs rsrzDataset.serializey sA.uWd##- #F  TX   rt)r]FN)r_r`rZrWrIr[r")rur)rur)rrrur|)rqrErrrurEr;)rarr\r[rurAr6)rrrr[rzr[rr[rrrrr|rrurF)rrrurA)rqrErrrurErwr)rrfrur)rurr0r1r2r3r4r5)NrNN)rr<r=r>rir@rrArrarrrrrrrrrrMrrrrrrDrEs@rsrFrF sWWv$-#,0 +++++++$%%X%&&&%%X%&&&////X/7777>>>>SSSSTTTTRV"2 "& $"&26,0:::::x    /3 7 7 7 7 7 7 7 /37777777:> , , , , , , ,4444 X ! X ! X!"% XJM!"% ''''X'JN""&            rtcNeZdZdZdfd Zdd ZddZdddZddZddZ xZ S)rHa 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. r_r`rarbcZtt|||dSrw)rhrHri)rqr_rarrs rsrizQuotedGraph.__init__ s+ k4  ))%<<<<. sx  1a![))  //Aq!$$01aL0///   rtr~rs` rsrzQuotedGraph.addN sJ     #       rtNrcrdr~c>d|j|zS)rz{%s}rrrs rsrzQuotedGraph.n3 rrtch|j}|jjj}d}|||fzS)NzK{this rdflib.identifier %s;rdflib:storage [a rdflib:Store;rdfs:label '%s']})rarr_rrr)rqralabelr\s rsrzQuotedGraph.__str__ s>_''))  $- 0 *e,,,rtrc,t|j|jffSrw)rHr_rarxs rsrzQuotedGraph.__reduce__ sTZ999rt)r_r`rarbr$r%rwr8r"r9) rr<r=r>rirrrrrrDrEs@rsrHrH s======    PPPPP----::::::::rtrH c:eZdZdZddZddZdd Zdd ZddZdS)rIa 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. 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! rrArr2cx|tx}|_tttdz}||D]T\}}||r:t||d}| ||fU| dS)N_r) r_listr/r~rr startswithrrqrsort)rqrrrLI_INDEXrris rsriz Seq.__init__ s 1!VV# #c((S.))++G44 % %DAq||H%% % (B//00 aV$$$  rtruc|Srwrrxs rsrz Seq.toPython rrtr)c#,K|jD] \}}|V dS)z#Generator over the items in the SeqN)r)rqrrs rsrz Seq.__iter__ s0z  GAtJJJJ  rtrc*t|jS)zLength of the Seq)rrrxs rsrz Seq.__len__ s4:rtr4c@|j|\}}|S)z Item given by index from the Seq)rr)rqindexrs rsrzSeq.__getitem__ s j,,U33 t rtN)rrArr2)rurI)rur)r))rur4) rr<r=r>rirrrrrrtrsrIrI s       rtrIceZdZddZddZdS) rJrur|cdSrwrrxs rsrizModificationException.__init__  rtr~c dS)NzZModifications and transactional operations not allowed on ReadOnlyGraphAggregate instancesrrxs rsrzModificationException.__str__ s /  rtNrur|r"rr<r=rirrrtrsrJrJ s<          rtrJceZdZddZddZdS) rKrur|cdSrwrrxs rsriz&UnSupportedAggregateOperation.__init__ rrtr~cdS)NzCThis operation is not supported by ReadOnlyGraphAggregate instancesrrxs rsrz%UnSupportedAggregateOperation.__str__ sWWrtNrr"rrrtrsrKrK sB    XXXXXXrtrKcTeZdZdZdWdXfd ZdYd ZdZd Zd[dZd[dZd\d]dZ d^dZ d_dZ d`dZ d_dZ edad Zedbd#Zedcd&Zdcd'Zddd*Zded,Zdfd.Zd[d/Zdfd0Zdgd5Zdgd6Z dhdid;Zdjd=ZdkdldAZ dkdmdGZdndIZdodpdLZ dqdrdRZdhdsdUZd[dVZxZ S)trLzUtility 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. r]r List[Graph]r_Union[str, Store]c|Jtt||t||d|_t |t r|r d|Ds Jd||_dS)Nc<g|]}t|t|Sr)rkrArrs rsrz3ReadOnlyGraphAggregate.__init__.. s';;;qjE&:&:;;;;rtz*graphs argument must be a list of Graphs!!)rhrLrirA*_ReadOnlyGraphAggregate__namespace_managerrkrr)rqrr_rrs rsrizReadOnlyGraphAggregate.__init__ s   ($ / / 8 8 ? ? ? NN4 ' ' ''+D $ vt $ $ 8 8<;F;;; 8 8 8  8 8 < rtrur~c0dt|jzS)Nz#)rrrxs rsrzReadOnlyGraphAggregate.__repr__ s4s4;7G7GGGrtrrctrwrJrs rsrzReadOnlyGraphAggregate.destroy #%%%rtctrwrrxs rsrzReadOnlyGraphAggregate.commit! rrtctrwrrxs rsrzReadOnlyGraphAggregate.rollback$ rrtFstr | tuple[str, str]rrWr|cH|jD]}||||dSrw)rr)rqrrrs rsrzReadOnlyGraphAggregate.open' s8[ 4 4E JJt]F 3 3 3 3  4 4rtcB|jD]}|dSrw)rr)rqrs rsrzReadOnlyGraphAggregate.close0 s,[  E KKMMMM  rtrrPctrwrrs rsrzReadOnlyGraphAggregate.add4 rrtrrctrwrrs rsrzReadOnlyGraphAggregate.addN7 rrtctrwrrs rsrzReadOnlyGraphAggregate.remove; rrtr9rcdSrwrrs rsrzReadOnlyGraphAggregate.triples? rrtr;rcdSrwrrs rsrzReadOnlyGraphAggregate.triplesE rrtr=rcdSrwrrs rsrzReadOnlyGraphAggregate.triplesK rrtc#K|\}}}|jD]b}t|tr%||||D] \}}|||fV <||||fD] \}}}|||fVcdSrw)rrkr$rr) rqrrrrrrrrs rsrzReadOnlyGraphAggregate.triplesQ s1a[ % %E!T"" %FF4A..""DAqQ'MMMM"#(--Aq ":":%%JBBb"*$$$$%  % %rtr]rTcd}t|dkr|d}|jD]#}||j|jkr|dd|vrdS$dS)NrmrlTF)rrra)rqr]rrs rsrz#ReadOnlyGraphAggregate.__contains__^ sk ~  ! # #$Q'G[  E%"2g6H"H"H!"1"%..44urtbGenerator[Tuple[_SubjectType, Union[Path, _PredicateType], _ObjectType, _ContextType], None, None]c#6 Kd t|dkr|\}}} n|\}}} ? fd|jDD])}||||fD]\}}}||||fV*dS|jD])}||||fD]\}}}||||fV*dS)z8Iterate over all the quads in the entire aggregate graphNrmc g|] }|k| Srr)rrrs rsrz0ReadOnlyGraphAggregate.quads..{ s;;;AFF!FFFrt)rrr) rqr]rrrrrrrrs @rsrzReadOnlyGraphAggregate.quadsj s  ~  ! # #'JAq!QQ%GAq! =;;;;T[;;; , ,"'--Aq ":":,,JBBb"e+++++, , , , ,"'--Aq ":":,,JBBb"e+++++, , ,rtrc>td|jDS)Nc34K|]}t|VdSrw)rrs rsrz1ReadOnlyGraphAggregate.__len__.. s(//a3q66//////rt)sumrrxs rsrzReadOnlyGraphAggregate.__len__ s!//4;//////rtctrwrKrxs rsrzReadOnlyGraphAggregate.__hash__ +---rtc|dSt|trdSt|tr!|j|jk|j|jkz SdS)Nr)rkrArLrrs rsrzReadOnlyGraphAggregate.__cmp__ sX =2 u % % 2 5 6 6 K%,.4;3MN N2rtrqr@rrctrwrrs rsrzReadOnlyGraphAggregate.__iadd__ rrtctrwrrs rsrzReadOnlyGraphAggregate.__isub__ rrtNr7rr8c#zK|\}}}|jD]*}||||f}|D] \}} } || | fV+dSrw)rr:) rqrrrrrrchoicesrrrs rsr:z&ReadOnlyGraphAggregate.triples_choices sv '-#G[  E++Wi,IJJG"  1aAg     rtrct|dr!|jr|j|StNrc)rrcrhrKris rsrhzReadOnlyGraphAggregate.qname sB 4, - - 5$2H 5)//44 4+---rtTrjrkct|dr"|jr|j||Str)rrcrmrKrns rsrmz$ReadOnlyGraphAggregate.compute_qname sF 4, - - G$2H G)77XFF F+---rtrr[rorrpctrwr)rqrrorps rsrzReadOnlyGraphAggregate.bind s,---rtrsc#Kt|dr'|jD] \}}||fV dS|jD]"}|D] \}}||fV #dSr)rrcrr)rqrrors rsrz!ReadOnlyGraphAggregate.namespaces s 4, - - ,%)%;%F%F%H%H ( (! i''''' ( ( , ,).)9)9););,,%FI )+++++, , ,rtrructrwrrxs rsrwz!ReadOnlyGraphAggregate.absolutize rrtrrrrzr|c trwr)rqrrrzr|s rsrzReadOnlyGraphAggregate.parse s$%%%rtrcrdctrwrrs rsrzReadOnlyGraphAggregate.n3 rrtctrwrrxs rsrz!ReadOnlyGraphAggregate.__reduce__ rrtrq)rrr_rr")rr~rur)rurr#)rrrrWrur|r)rrPrur)rrrurr&r'r(r)r]rTrur r))rqr@rrrurrwr*r+r,r-)rr[rorrprWrurr.r/)rr~rurrurr;) rrrr[rzr[r|rrur)rcrdrur)!rr<r=r>rirrrrrrrrrrrrrrrrrrr:rhrmrrrwrrrrDrEs@rsrLrL s       HHHH&&&&&&&&&&&&44444&&&&&&&&&&&&111X1 555X5 ===X= % % % %    ,,,,20000....&&&&&&&&+/     .... .....GK..... ,,,,.....#' $ & & & & &.............rtrLtermsr-rute.Literal[True]cdSrwrr$s rsrr s363rtrrWcdSrwrr's rsrr s&)crtcV|D]%}t|tsJd|d&dS)NzTerm rT)rkr-)r$rs rsrr sC LL!T""KKK$KKK"K 4rtcDeZdZdZddd Zdd ZddZddZddZddZ dS)rMa?Wrapper 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 FrrA batch_sizer batch_addnrWc|r|dkrtd||_|f|_||_||_|dS)NrLz$batch_size must be a positive number)rRr_BatchAddGraph__graph_tuple_BatchAddGraph__batch_size_BatchAddGraph__batch_addnreset)rqrr,r-s rsrizBatchAddGraph.__init__ sT EZ!^^CDD D #X&& rtruc"g|_d|_|S)zQ Manually clear the buffered triples and reset the count to zero r)batchcountrxs rsr2zBatchAddGraph.reset s')   rtr]Union[_TripleType, _QuadType]cLt|j|jkr&|j|jg|_|xjdz c_t|dkr#|j||jzn|j||S)zAdd a triple to the buffer. Args: triple_or_quad: The triple or quad to add Returns: The BatchAddGraph instance rrl)rr4r0rrr5rr/)rqr]s rsrzBatchAddGraph.add s tz??d/ / / JOODJ ' ' 'DJ a ~  ! # # J  nt/AA B B B B J  n - - - rtrrc~|jr|D]}||n|j||Srw)r1rrr)rqrqs rsrzBatchAddGraph.addN" sM   #     JOOE " " " rtc.||Srw)r2rxs rs __enter__zBatchAddGraph.__enter__* s  rtr|cX|d!|j|jdSdS)Nr)rrr4)rqexcs rs__exit__zBatchAddGraph.__exit__. s. q6> JOODJ ' ' ' ' ' >rtN)r+F)rrAr,rr-rW)rurM)r]r6rurM)rrrurMr) rr<r=r>rir2rrr;r>rrtrsrMrM s 6((((((rtrM)r$r-rur%)r$rrurW)zr> __future__rloggingrrrPiortypingrrrrr r r r r rrrrrrrrrrr urllib.parserurllib.requestrrdflib.exceptionsrHrdflib.namespacero rdflib.pluginrl rdflib.queryr rdflib.utilr^rdflib.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?rQr7r@rCrErdflib._type_checkingrG getLoggerrr__all__rUrAr5rDrrFrHterm _ORDERINGrIrrJrKrLrrMrrtrsrXsJJX#""""" ,"!!!!!''''''&&&&&&$$$$$$(((((())))))==========BBBBBBBBBB$$$$$$((((((                    ;""""::::::::  'CD Q R $mXn5MM""DE#$mX>V5WW ^h'78(=:QQx7x ?VVW ^  ] ^  ^ ] ^ !!IJ$%UV ^ U+ ,- ]  ^ U+ ,- ] ^ ""LMm;< @A $| h~68M MN (< $~"68M MN (< (>":D