iTdZddlmZddlZddlZddlZddlZddlmZddl 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&ldmeZeejegZhgd'Zied(ZjGd)d eDZkekZlGd*d#ekZmeFd+ZnGd,d%emZoGd-d.ekZpd/e+jjep<Gd0d1ZsGd2d3etZuGd4d5etZvGd6d7emZwed=d8Zxed>d9Zxd>d:ZxGd;d<Zyy)?a% RDFLib defines the following kinds of Graphs: * :class:`~rdflib.graph.Graph` * :class:`~rdflib.graph.QuotedGraph` * :class:`~rdflib.graph.ConjunctiveGraph` * :class:`~rdflib.graph.Dataset` Graph ----- An RDF graph is a set of RDF triples. Graphs support the python ``in`` operator, as well as iteration and some operations like union, difference and intersection. see :class:`~rdflib.graph.Graph` Conjunctive Graph ----------------- .. warning:: ConjunctiveGraph is deprecated, use :class:`~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 :class:`~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 :class:`~rdflib.term.BNode` for an identifier - if one isn't given. see :class:`~rdflib.graph.ConjunctiveGraph` Quoted graph ------------ The notion of an RDF graph [14] is extended to include the concept of a formula node. A formula node may occur wherever any other kind of node can appear. Associated with a formula node is an RDF graph that is completely disjoint from all other graphs; i.e. has no nodes in common with any other graph. (It may contain the same labels as other RDF graphs; because this is, by definition, a separate graph, considerations of tidiness do not apply between the graph at a formula node and any other graph.) This is intended to map the idea of "{ N3-expression }" that is used by N3 into an RDF graph upon which RDF semantics is defined. see :class:`~rdflib.graph.QuotedGraph` Dataset ------- The RDF 1.1 Dataset, a small extension to the Conjunctive Graph. The primary term is "graphs in the datasets" and not "contexts with quads" so there is a separate method to set/retrieve a graph in a dataset and to operate with dataset graphs. As a consequence of this approach, dataset graphs cannot be identified with blank nodes, a name is always required (RDFLib will automatically add a name if one is not provided at creation time). This implementation includes a convenience method to directly add a single quad to a dataset graph. see :class:`~rdflib.graph.Dataset` Working with graphs =================== Instantiating Graphs with default store (Memory) and default identifier (a BNode): >>> g = Graph() >>> g.store.__class__ >>> g.identifier.__class__ Instantiating Graphs with a Memory store and an identifier - : >>> 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": >>> 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: >>> 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 :meth:`~rdflib.graph.Graph.triples` can be thought of as "open variables". Graph support set-theoretic operators, you can add/subtract graphs, as well as intersection (with multiplication operator g1*g2) and xor (g1 ^ g2). Note that BNode IDs are kept when doing set-theoretic operations, this may or may not be what you want. Two named graphs within the same application probably want share BNode IDs, two graphs with data from different sources probably not. If your BNode IDs are all generated by RDFLib they are UUIDs and unique. >>> g1 = Graph() >>> g2 = Graph() >>> u = URIRef("http://example.com/foo") >>> g1.add([u, 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: >>> 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 :meth:`~rdflib.graph.ConjunctiveGraph.quads` method which returns quads instead of triples, where the fourth item is the Graph (or subclass thereof) instance in which the triple was asserted: >>> uniqueGraphNames = set( ... [graph.identifier for s, p, o, graph in ConjunctiveGraph(store ... ).quads((None, RDF.predicate, None))]) >>> len(uniqueGraphNames) 3 >>> unionGraph = ReadOnlyGraphAggregate([g1, g2]) >>> uniqueGraphNames = set( ... [graph.identifier for s, p, o, graph in unionGraph.quads( ... (None, RDF.predicate, None))]) >>> len(uniqueGraphNames) 2 Parsing N3 from a string >>> g2 = Graph() >>> src = ''' ... @prefix rdf: . ... @prefix rdfs: . ... [ a rdf:Statement ; ... rdf:subject ; ... rdf:predicate rdfs:label; ... rdf:object "Conjunctive Graph" ] . ... ''' >>> g2 = g2.parse(data=src, format="n3") >>> print(len(g2)) 4 Using Namespace class: >>> RDFLib = Namespace("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_TCArgTceZdZUdZded<ded<ded<ded< d[ d\fd Zed]d Zed^d Zed_d Z e jd`d Z dadZ dadZ dbdZ dcdZdbdZdbdZdddedZdddfdZdgdZdhdZdidZe djdZe dkdZe dldZ dldZdZdmdZdndZdod Zdmd!Zdmd"Zdpd#Zdpd$Zdqd%Z dpd&Z!dqd'Z"drd(Z#drd)Z$dsd*Z%dsd+Z&dsd,Z'dsd-Z(e%Z)e&Z* dtd.Z+ du dvd/Z, du dwd0Z- du dxd1Z. dy dzd2Z/ dy d{d3Z0 dy d|d4Z1 d} d~d5Z2e d dd6Z3e d dd7Z3e d dd8Z3e d dd9Z3de4jfddd:f dd;Z3dd<Z5 d} dd=Z6 d} dd>Z7 d} dd?Z8dd@Z9dddAZ: d ddBZ;ddCZe d ddFZ>e d ddGZ>e d ddHZ>e d ddIZ> d ddJZ> d ddKZ? d ddLZ@ d ddMZA d ddNZBd}ddOZCddPZDdqdQZEdpdRZFddSZGddTZHddUZI ddVZJ d ddWZK d ddXZLddY ddZZMxZNS)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 it all uses of RDFLib. The basic use is to create a Graph and iterate through or query its content, e.g.: >>> 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") ... ) The constructor accepts one argument, the "store" that will be used to store the graph data with the default being the `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. See the :doc:`rdflib.plugins.stores` package for Stores currently shipped with RDFLib. Other Stores not shipped with RDFLib can be added, such as `HDT `_. 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, https://www.w3.org/TR/trig/. bool context_aware formula_aware default_union Optional[str]baseNctt| ||_||xs t |_t |j tst|j |_|t |ts'tj|tx|_ }n||_ ||_ ||_d|_d|_d|_yNF)superrA__init__r\r(_Graph__identifier isinstancer*r/r'pluginget _Graph__store_Graph__namespace_manager_bind_namespacesrXrYrZ)selfstore identifiernamespace_managerr\bind_namespaces __class__s ;C:\Projects\mas-dev\.venv\Lib\site-packages\rdflib/graph.pyr`zGraph.__init__s eT#%  &1%'$++^< &t'8'8 9D  %'#;6::eU#;#= =DL5 DL#4 /"""c|jSN)rerhs rnriz Graph.stores ||roc|jSrq)rarrs rnrjzGraph.identifiers   roch|jt||j|_|jS)z0 this graph's namespace-manager )rfr rgrrs rnrkzGraph.namespace_managers1  # # +'7d>S>S'TD $'''roc||_yrq)rf)rhnms rnrkzGraph.namespace_managers #% roc:d|jdt|dS)Nz)rjtyperrs rn__repr__zGraph.__repr__s/3T KKroct|jtr>|jjd|jj j dSd|jj j zS)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__rrs rn__str__z Graph.__str__sc doov .##%tzz';';'D'DF F W $$--. .roc|Srqrrs rntoPythonzGraph.toPython" roc<|jj||S)z>Destroy the store identified by ``configuration`` if supported)redestroyrh configurations rnrz Graph.destroy%s ]+ roc:|jj|S)zCommits active transactions)recommitrrs rnrz Graph.commit+s  roc:|jj|S)zRollback active transactions)rerollbackrrs rnrzGraph.rollback0s  roc:|jj||S)zOpen the graph store Might be necessary for stores that require opening a connection to a database or acquiring some resource. )reopen)rhrcreates rnrz Graph.open5s ||  77roc:|jj|S)zClose the graph store Might be necessary for stores that require closing a connection to a database or releasing some resource. )commit_pending_transaction)reclose)rhrs rnrz Graph.close=s ||!!=W!XXroc|\}}}t|ts Jd|dt|ts Jd|dt|ts Jd|d|jj|||f|d|S)!Add a triple with self as contextSubject  must be an rdflib term Predicate Object Fquoted)rbr-readdrhtriplespos rnrz Graph.addEsy1a!T"N1$NN"!T"PQ$PP"!T"M!$MM" !QD7 rocPjjfd|DS)%Add a sequence of triple with contextc3K|]D\}}}}t|tr-|jjurt|||r||||fFywrq)rbrArj _assertnode.0rrrcrhs rn zGraph.addN..QsO # 1a!U# /Aq!$ 1aL#A A )readdNrhquadss` rnrz Graph.addNNs+  #   roc@|jj|||S)zRemove a triple from the graph If the triple does not provide a context attribute, removes the triple from all contexts. context)reremoverhrs rnrz Graph.removeZs FD1 rocyrqrrs rntriplesz Graph.triplesc.1rocyrqrrs rnrz Graph.triplesi25rocyrqrrs rnrz Graph.tripleso:=roc#K|\}}}t|tr#|j|||D] \}}|||fy|jj |||f|D]\\}}}}|||fyw)zGenerator over the triple store Returns triples that match the given triple pattern. If triple pattern does not provide a context, all contexts will be searched. rN)rbr$evalrer) rhrrrr_s_o_pcgs rnrz Graph.triplesus1a a &&q!,B!Ri-%)LL$8$8!QD$8$Q Rb"bj %RsA.A0ct|tr|j|j|j}}}||||j |||fS|||j |S|||j|S|||j|S||j||S||j||S||j||S|||f|vSt|ttfr|j|Std)aN A graph can be "sliced" as a shortcut for the triples method The python slice syntax is (ab)used for specifying triples. A generator over matches is returned, the returned tuples include only the parts not given >>> import rdflib >>> g = rdflib.Graph() >>> g.add((rdflib.URIRef("urn:bob"), 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. .. versionadded:: 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__zGraph.__getitem__sT dE "jj$))TYY!qAyQY19||Q1I..qy..q11qy++A..qy--a00}}Q**q!,,||Aq))1ayD(( tTl +))$/ /i roc:|jj|S)zReturns the number of triples in the graph If context is specified then the number of triples in the context is returned instead. r)re__len__rrs rnrz Graph.__len__s||##D#11roc$|jdS)z&Iterates over all triples in the storeNNNrrrs rn__iter__zGraph.__iter__s||.//roc2|j|D]}yy)z$Support for 'triple in graph' syntaxTFrrs rn __contains__zGraph.__contains__sll6*F+roc,t|jSrq)hashrjrrs rn__hash__zGraph.__hash__sDOO$$roc|yt|tr3|j|jkD|j|jkz Sy)NrbrArjrhothers rn__cmp__z Graph.__cmp__sG = u %OOe&6&66%"2"22 rocXt|txr|j|jk(Srqrrs rn__eq__z Graph.__eq__s#%'ODOOu?O?O,OOrocd|duxs+t|txr|j|jkSrqrrs rn__lt__z Graph.__lt__s1  ue $ K5;K;K)K roc||kxs||k(Srqrrs rn__le__z Graph.__le__e|,tu},rocdt|txr|j|jkDxs|duSrqrrs rn__gt__z Graph.__gt__s25%(OT__u?O?O-O   roc||kDxs||k(Srqrrs rn__ge__z Graph.__ge__rroc<jfd|DS)zKAdd all triples in Graph other to Graph. BNode IDs are not changed.c32K|]\}}}|||fywrqr)rrrrrhs rnrz!Graph.__iadd__..s 7gaA1aD/s)rrs` rn__iadd__zGraph.__iadd__s 777 roc6|D]}|j||S)zRSubtract all triples in Graph other from Graph. BNode IDs are not changed.)r)rhrrs rn__isub__zGraph.__isub__ sF KK  rocf t|}tt |j t |j zD]\}}|j |||D]}|j||D]}|j||S#t$r t}YwxYw)z6Set-theoretic union BNode IDs are not changed.)rxrrAsetlist namespacesbindr)rhrretvalprefixurixys rn__add__z Graph.__add__s T$Z\FtDOO$56e>N>N>P9QQRKFC KK $SA JJqMA JJqM  WF sBB0/B0c t|}|D]}||vs|j||S#t$r t}Y4wxYw)z>Set-theoretic intersection. BNode IDs are not changed.rxrrArrhrrrs rn__mul__z Graph.__mul__sQ T$Z\FADy 1   WF 1AAc t|}|D]}||vs|j||S#t$r t}Y4wxYw)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)rhrsubject predicateobject_s rnrz Graph.setAsm)/%)W   L K L   ! L K L ! Wi./ '9g./ roc#Kt|tr$|D]}|j|||D]}| y|s"|jd||fD] \}}}| yt }|jd||fD]!\}}}||vs | |j |#y#t $r} tj| dd} ~ wwxYww)zZA generator of (optionally unique) subjects with the given predicate and object(s)N1. Consider not setting parameter 'unique' to True) rbrrrrr MemoryErrorloggererror) rhrobjectuniqueobjrrrsubses rnrzGraph.subjectsTs fd #y#v>AG?#||T9f,EFGAq!G Gu#||T9f,EFGAq!}" HHQK G +""LL#$#%V W" "0BCC BC C'CCCc#,K|s"|j|d|fD] \}}}| yt}|j|d|fD]!\}}}||vs | |j|#y#t$r}tj |dd}~wwxYww)zWA generator of (optionally unique) predicates with the given subject and objectNrrrrrrr) rhrr r rrrpredsr s rnrzGraph.predicatesrs<<$(?@1aAEE<<$(?@1aE>G ! A '  c!RS s0ABBA*'B* B3B  BBc#Kt|tr$|D]}|j|||D]}| y|s"|j||dfD] \}}}| yt }|j||dfD]!\}}}||vs | |j |#y#t $r} tj| dd} ~ wwxYww)zZA generator of (optionally unique) objects with the given subject(s) and predicateNr) rbrrrrrrrr) rhrrr subjrrrobjsr s rnrz Graph.objectss gt $dIv>AG? #||Wi,FGGAq!G Hu#||Wi,FGGAq!}" HHQK H +""LL#$#%V W" "rc#<K|s$|jdd|fD] \}}}||fyt}|jdd|fD]'\}}}||f|vs||f |j||f)y#t$r}tj |dd}~wwxYww)z[A generator of (optionally unique) (subject, predicate) tuples for the given objectNrr)rhr r rrr subj_predsr s rnrzGraph.subject_predicatess <<tV(<=1ad >J<<tV(<=1aq6+Q$J"1v. > '  c!RS 0ABBA2/B2 B;BBBc#<K|s$|jd|dfD] \}}}||fyt}|jd|dfD]'\}}}||f|vs||f |j||f)y#t$r}tj |dd}~wwxYww)z[A generator of (optionally unique) (subject, object) tuples for the given predicateNrr)rhrr rrr subj_objsr s rnrzGraph.subject_objectss<<y$(?@1ad AI<<y$(?@1aq6*Q$J! q!f- A '  c!RS rc#<K|s$|j|ddfD] \}}}||fyt}|j|ddfD]'\}}}||f|vs||f |j||f)y#t$r}tj |dd}~wwxYww)z[A generator of (optionally unique) (predicate, object) tuples for the given subjectNrr)rhrr rrr pred_objsr s rnrzGraph.predicate_objectss <<$(=>1ad ?I<<$(=>1aq6*Q$J! q!f- ? '  c!RS rc#~K|\}}}|jj|||f|D]\\}}}} |||fyw)Nr)ritriples_choices) rhrrrrrrrrrs rnrzGraph.triples_choicessW '-#G"ZZ77 i )48 MIQ1rQ'M s;=cyrqrrhrrr defaultanys rnvaluez Graph.valuerocyrqrrs rnr"z Graph.valuer#rocyrqrrs rnr"z Graph.value r#rocyrqrrs rnr"z Graph.valuesroTc |}||||||y||j||}||j||}||j||} t}|duru t|d|d|d|d}|jj |||fd} | D]$\\} } } } |d| d| d| dt | d z }&tj||S#t$rY|SwxYw#t$r|}Y|SwxYw) aGet a value for a pair of two criteria Exactly one of subject, predicate, object must be None. Useful if one knows that there may only be one value. It is one of those situations that occur a lot, hence this 'macro' like utility Parameters: - subject, predicate, object: exactly one must be None - default: value to be returned if no values found - any: if True, return any value in the case there is more than one, else, raise UniquenessError NFz"While trying to find a value for (z, z-) the following multiple values where found: (z) (contexts: z) ) rrrnextrirr exceptionsUniquenessError StopIteration)rhrrr r r!rvaluesmsgrrrrcontextss rnr"z Graph.valuesC._!2FN!fn >\\'95F ?]]9f5F  __Wf5F &\Fe|L#Iv7 #jj00'9f1MtTG/6+ Aq8 N  07%44S99 % ) F* - s% C#A4C C C # C21C2c#Kt|g}|rj|j|tj}|||j|tj}||vr t d|j ||riyyw)zgGenerator over all items in the resource specified by list list is an RDF collection. Nz,List contains a recursive rdf:rest reference)rr"rfirstrest ValueErrorr)rhrchainrs rnitemsz Graph.items^sl TF ::dCII.D ::dCHH-Du} !OPP IIdOs A7A<:A<c#K|i}n||vryd||<|||D]"}||j|||D]}|$yw)a Generates transitive closure of a user-defined function against the graph >>> from rdflib.collection import Collection >>> g = Graph() >>> a = BNode("foo") >>> b = BNode("bar") >>> c = BNode("baz") >>> g.add((a,RDF.first,RDF.type)) # doctest: +ELLIPSIS )> >>> g.add((a,RDF.rest,b)) # doctest: +ELLIPSIS )> >>> g.add((b,RDF.first,namespace.RDFS.label)) # doctest: +ELLIPSIS )> >>> g.add((b,RDF.rest,c)) # doctest: +ELLIPSIS )> >>> g.add((c,RDF.first,namespace.RDFS.comment)) # doctest: +ELLIPSIS )> >>> g.add((c,RDF.rest,RDF.nil)) # doctest: +ELLIPSIS )> >>> def topList(node,g): ... for s in g.subjects(RDF.rest, node): ... yield s >>> def reverseList(node,g): ... for f in g.objects(node, RDF.first): ... print(f) ... for s in g.subjects(RDF.rest, node): ... yield s >>> [rt for rt in g.transitiveClosure( ... topList,RDF.nil)] # doctest: +NORMALIZE_WHITESPACE [rdflib.term.BNode('baz'), rdflib.term.BNode('bar'), rdflib.term.BNode('foo')] >>> [rt for rt in g.transitiveClosure( ... reverseList,RDF.nil)] # doctest: +NORMALIZE_WHITESPACE http://www.w3.org/2000/01/rdf-schema#comment http://www.w3.org/2000/01/rdf-schema#label http://www.w3.org/1999/02/22-rdf-syntax-ns#type [rdflib.term.BNode('baz'), rdflib.term.BNode('bar'), rdflib.term.BNode('foo')] Nr)transitiveClosure)rhfuncargseenrtrt_2s rnr7zGraph.transitiveClosurensYh <D D[ S sD/BH..tR> ?"?Ac#K|i}||vryd||<||j||D]}|j|||D]}| yw)zTransitively generate objects for the ``predicate`` relationship Generated objects belong to the depth first transitive closure of the ``predicate`` relationship starting at ``subject``. Nr)rtransitive_objects)rhrrrememberr rs rnr?zGraph.transitive_objectssa  H h   ll7I6F,,VYIJ7AA c#K|i}||vryd||<||j||D]}|j|||D]}| yw)zTransitively generate subjects for the ``predicate`` relationship Generated subjects belong to the depth first transitive closure of the ``predicate`` relationship starting at ``object``. Nr)rtransitive_subjects)rhrr r@rrs rnrCzGraph.transitive_subjectssa  H X   }}Y7G--i(KL8rAc8|jj|Srq)rkqnamerhrs rnrEz Graph.qnames%%++C00roc:|jj||Srq)rk compute_qnamerhrgenerates rnrHzGraph.compute_qnames%%33CBBroc@|jj||||S)a6Bind prefix to namespace If override is True will bind namespace to given prefix even if namespace was already bound to a different prefix. if replace, replace any existing prefix with the new namespace for example: graph.bind("foaf", "http://xmlns.com/foaf/0.1/") )overridereplace)rkr)rhr namespacerLrMs rnrz Graph.binds+0%%** I'+  roc#\K|jjD] \}}||f yw)z/Generator over all the prefix, namespace tuplesN)rkr)rhrrNs rnrzGraph.namespacess0!%!7!7!B!B!D FI)# #"Es*,c:|jj||S)z5Turn uri into an absolute URI if it's not one already)rk absolutizerhrdefrags rnrQzGraph.absolutizes%%00f==roc yrqrrh destinationformatr\encodingargss rn serializezGraph.serializeroc yrqrrUs rnrZzGraph.serialize sroc yrqrrUs rnrZzGraph.serializesroc yrqrrUs rnrZzGraph.serialize$r[roc yrqrrUs rnrZzGraph.serialize/s$'roc | |j}tj|t|}|gt }|5|j |f|dd||j jdS|j |f||d||j St|dr/ttt|}|j |f||d||St|tjr t|}nItt|} t!| \} } } } }}| dk(r | dk7rt#d| dt%| }n| }t'|d 5}|j |f||d|ddd|S#1swY|SxYw) a Serialize the graph. :param destination: The destination to serialize the graph to. This can be a path as a :class:`str` or :class:`~pathlib.PurePath` object, or it can be a :class:`~typing.IO` ``[bytes]`` like object. If this parameter is not supplied the serialized graph will be returned. :param format: The format that the output should be written in. This value references a :class:`~rdflib.serializer.Serializer` plugin. Format support can be extended with plugins, but ``"xml"``, ``"n3"``, ``"turtle"``, ``"nt"``, ``"pretty-xml"``, ``"trix"``, ``"trig"``, ``"nquads"``, ``"json-ld"`` and ``"hext"`` are built in. Defaults to ``"turtle"``. :param base: The base IRI for formats that support it. For the turtle format this will be used as the ``@base`` directive. :param encoding: Encoding of output. :param args: Additional arguments to pass to the :class:`~rdflib.serializer.Serializer` that will be used. :return: 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. :rtype: :class:`bytes` if ``destination`` is `None` and ``encoding`` is not `None`. :rtype: :class:`str` if ``destination`` is `None` and ``encoding`` is `None`. :return: ``self`` (i.e. the :class:`~rdflib.graph.Graph` instance) if ``destination`` is not `None`. :rtype: :class:`~rdflib.graph.Graph` if ``destination`` is not `None`. Nutf-8)r\rXwritefilez the file URI z2 has an authority component which is not supportedwb)r\rcrdr&rrZgetvaluedecodehasattrrrbytesrbpathlibPurePathstrrr3rr)rhrVrWr\rXrY serializerstreamos_pathlocationschemenetlocpathparams_queryfragments rnrZzGraph.serialize9sR <99D3VZZ 3D9  YF$ $$VQ$QDQ(//88$ $$VR$RTR(( ; ("U)[1F J  NdX N N" +w'7'78k*[1AI(AS>ffhV#|(+H<7ij+40G&Ggt$$ $$VR$RTR% % s E//E9cbt|jd||j||dy)N)rWrXT)rcflush)printrZrg)rhrWrXouts rnryz Graph.prints/  NN4N B I I( S roc dt||||||}| |j}d}|t|drnt|jddrWt |jj tr3tjj|jj }|d}d} tj|t} | j ||fi| |j&r|j)|S#tj$r_tjjt |ts|n t|}|tj|t} YwxYw#t"$r} |rt%d|z| d} ~ wwxYw#|j&r|j)wwxYw) a Parse an RDF source adding the resulting triples to the Graph. The source is specified using one of source, location, file or data. .. 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 :doc:`Security Considerations ` documentation. :param 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. :param location: A string indicating the relative or absolute URL of the source. `Graph`'s absolutize method is used if a relative location is specified. :param file: A file-like object. :param data: A string containing the data to be parsed. :param format: Used if format can not be determined from source, e.g. file extension or Media Type. Defaults to text/turtle. Format support can be extended with plugins, but "xml", "n3" (use for turtle), "nt" & "trix" are built in. :param 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. :return: ``self``, i.e. the :class:`~rdflib.graph.Graph` instance. Examples: >>> 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 sourcepublicIDrprcdatarWNFrcnameturtleTzCould 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_typerhgetattrrcrbrrlrdflibutil guess_formatrcrdr"PluginExceptionr!parse SyntaxErrorr auto_closer) rhr}r~rWrprcrrYcould_not_guess_formatparserses rnrz Graph.parses~%   >((F!& >'FKK6v{{//511&++2B2BC~!)-& 2/VZZ/1F  FLL . .    3%% 2[[--(=3v;F~/VZZ/1F 2 %!S     !s7%C8E-8A/E*)E*- F 6FF  FF/c |xsi}|xst|j}|jrd}n3t|tr|j j }n |j }t|jdr#|r! |jj||||fi|St|tjs2tjtt|tj}t|tj s*tj|tj |}||j|||fi|S#t$rYwxYw)a Query this graph. A type of 'prepared queries' can be realised by providing initial variable bindings with initBindings Initial namespaces are used to resolve prefixes used in the query, if none are given, the namespaces from the graph's namespace manager are used. .. 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 :doc:`Security Considerations ` documentation. :returntype: :class:`~rdflib.query.Result` __UNION__query)dictrrZrbrDdefault_contextrjrhrirNotImplementedErrorResultrcrdrrl Processor) rh query_object processorresultinitNs initBindingsuse_store_providedkwargs query_graphs rnrz Graph.query!s&J$)r 24 12   %K . /..99K//K 4::w ',> 'tzz''     &%,,/ZZS& 15<<@F)U__5> 9eoo>tDIoioolL&SFSTT'  s?E EEc |xsi}|xst|j}|jrd}n3t|tr|j j }n |j }t|jdr#|r! |jj||||fi|St|tjs*tj|tj|}|j|||fi|S#t$rYdwxYw)a^ Update this graph with the given update query. .. 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 :doc:`Security Considerations ` documentation. rupdate)rrrZrbrDrrjrhrirrrUpdateProcessorrcrd)rh update_objectrrrrrrs rnrz Graph.updatecs2$)r 24 12   %K . /..99K//K 4::x (-? (tzz((!    )U%:%:;D 9e.C.CDTJIy |VNvNN '  s?C88 DDc@d|jj|zS)%Return an n3 identifier for the Graphz[%s]rkrjr{rhrks rnr{zGraph.n3 **=N*OOOroc>t|j|jffSrq)rArirjrrs rn __reduce__zGraph.__reduce__s"     roc t|t|k7ry|D]1\}}}t|trt|tr)|||f|vs1y|D]1\}}}t|trt|tr)|||f|vs1yy)z does a very basic check if these graphs are the same If no BNodes are involved, this is accurate. See rdflib.compare for a correct implementation of isomorphism checks FT)lenrbr()rhrrrrs rn isomorphiczGraph.isomorphics t9E "GAq!a' 1e0D1ayE) GAq!a' 1e0D1ayD(  roct|j}g}|sy|tjt |g}|r|j }||vr|j ||j|D]}||vs||vs |j ||j|D]}||vs||vs |j ||rt |t |k(ryy)aCheck if the Graph is connected The Graph is considered undirectional. Performs a search on the Graph, starting from a random node. Then iteratively goes depth-first through the triplets where the node is subject and object. Return True if all nodes have been visited and False if it cannot continue and there are still unvisited nodes left. F)r)r T) r all_nodesrandom randrangerpopappendrr)rhr discoveredvisitingrnew_xs rn connectedzGraph.connecteds)*  f..s9~>?@ A "!!!$a0 *uH/DOOE*1a0 *uH/DOOE*1 y>S_ ,rocvt|j}|j|j|Srq)rrrr)rhress rnrzGraph.all_nodess)$,,.! 4==?# roct||S)aCreate a new ``Collection`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> collection = graph.collection(uri) >>> assert isinstance(collection, Collection) >>> assert collection.uri is uri >>> assert collection.graph is graph >>> collection += [ Literal(1), Literal(2) ] rrhrjs rn collectionzGraph.collections$$ ++rocPt|ts t|}t||S)aCreate a new ``Resource`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> resource = graph.resource(uri) >>> assert isinstance(resource, Resource) >>> assert resource.identifier is uri >>> assert resource.graph is graph )rbr-r/r%rs rnresourcezGraph.resources%"*d+ +Jj))roc^|jdD]}|j||y)Nr)rr)rhtargetr8ts rn_process_skolem_tupleszGraph._process_skolem_tuples s(01A JJtAw 2rocdfd dfd }| tn|}|j|||Sttr|j|fd|S)Nc|\}}}||k(r+trt|tsJ|j}||k(r+trt|tsJ|j}|||fSN) authoritybasepath)rrbr( skolemize)bnoderrrrrrs rn do_skolemizez%Graph.skolemize..do_skolemizesqIQ1Ez %a///KK)hKGEz %a///KK)hKGa7Nroc|\}}}t|tr|j}t|tr|j}|||fSr)rbr(r)rrrrrrs rn do_skolemize2z&Graph.skolemize..do_skolemize2%sQIQ1!U#KK)hKG!U#KK)hKGa7Nroc|Srqr)rrrs rnz!Graph.skolemize..3s ,ua:Pro)rr(rr6returnr6rr6rr6)rArrbr()rh new_graphrrrrrrs ``` @rnrzGraph.skolemizes[  &-9 =  ' ' >  u %  ' '0P Q rocdddd}| tn|}|j|||Sttr|j|fd|S)Nc|\}}}||k(r(trt|tsJ|j}||k(r(trt|tsJ|j}|||fSrq)rrbr/ de_skolemize)urirefrrrrs rndo_de_skolemizez+Graph.de_skolemize..do_de_skolemize:sdIQ1F{ %a000NN$F{ %a000NN$a7Nroc|\}}}tj|rt|j}n.tj|rt|j}t |t r]tj|rt|j}n.tj|rt|j}|||fSrq)r._is_rdflib_skolemrr)_is_external_skolemrbr/)rrrrs rndo_de_skolemize2z,Graph.de_skolemize..do_de_skolemize2FsIQ1,,Q/N//1**1-!H))+!V$003#A335A..q1a--/Aa7Nroc|Srqr)rrrs rnrz$Graph.de_skolemize..^s /&RS:Tro)rr/rr6rr6r)rArrbr))rhrrrrrs ` @rnrzGraph.de_skolemize7s\  $&-9 >  ' '0@ A   &  ' '0T U ro) target_graphcJ| tn|dfd |S)aRetrieves the Concise Bounded Description of a Resource from a Graph Concise Bounded Description (CBD) is defined in [1] 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. [1] https://www.w3.org/Submission/CBD/ :param resource: a URIRef object, of the Resource for queried for :param target_graph: Optionally, a graph to add the CBD to; otherwise, a new graph is created for the CBD :return: a Graph, subgraph of self if no graph was provided otherwise the provided graph cdj|ddfD]<\}}} j|||ft|tus-|ddf vs5|>jdtj |fD]7\}}}j|ddfD]\}}} j|||f9yrq)rrrxr(rr) rrrrs2p2o2 add_to_cbdrhsubgraphs rnrzGraph.cbd..add_to_cbds<<dD(9:1a aAY'7e#D$x(GqM ; <<s{{C(@A1a"&,,4"?JBBLL"b".#@Bro)rr2rNone)rA)rhrrrrs` @@rncbdz Graph.cbdbs,@  wH#H /$ 8ro)r NNNr) riUnion[Store, str]rj,Optional[Union[_ContextIdentifierType, str]]rkOptional[NamespaceManager]r\r[rlrG)rr')rr8)rr )rvr rrrrl)rhr@rr@)rhr@rrlrr@F)rrlrrWrz Optional[int])rrWrrrhr@rr6rr@rhr@rIterable[_QuadType]rr@)rhr@rr9rr@rr9r"Generator[_TripleType, None, None]rr;r&Generator[_TriplePathType, None, None]rr=r.Generator[_TripleOrTriplePathType, None, None]rint)rr)rr=rrW)rrW)rrArrW)rhr@rIterable[_TripleType]rr@)rrArrA)rhr@rz0Tuple[_SubjectType, _PredicateType, _ObjectType]rr@)NNF)r!Union[None, Path, _PredicateType]r z/Optional[Union[_ObjectType, List[_ObjectType]]]r rWrz#Generator[_SubjectType, None, None])rOptional[_SubjectType]r Optional[_ObjectType]r rWrz%Generator[_PredicateType, None, None])rz1Optional[Union[_SubjectType, List[_SubjectType]]]rrr rWr"Generator[_ObjectType, None, None]r^)r rr rWrz:Generator[Tuple[_SubjectType, _PredicateType], None, None])rrr rWrz7Generator[Tuple[_SubjectType, _ObjectType], None, None])rrr rWrz9Generator[Tuple[_PredicateType, _ObjectType], None, None]rqr_TripleChoiceTyperOptional[_ContextType]rr).....) rrrrr rr Optional[Node]r!rWrr) rrrrr rr rr!rWrr) rrrOptional[_PredicateType]r rr rr!rWrr) rrrrr rr rr!rWrr)rr-rzGenerator[Node, None, None])r8z-Callable[[_TCArgT, Graph], Iterable[_TCArgT]]r9rUr:zOptional[Dict[_TCArgT, int]])rrrrr@z+Optional[Dict[Optional[_SubjectType], int]]rz-Generator[Optional[_SubjectType], None, None])rrr rr@z*Optional[Dict[Optional[_ObjectType], int]]rz,Generator[Optional[_ObjectType], None, None]rrlrrlTrrlrJrWrzTuple[str, URIRef, str])TF) rr[rNrrLrWrMrWrrrz)Generator[Tuple[str, URIRef], None, None]r)rrlrSrrr/) rVrrWrlr\r[rXrlrYrrri)...)....) rVrrWrlr\r[rXrrYrrrl) rVz'Union[str, pathlib.PurePath, IO[bytes]]rWrlr\r[rXr[rYrrrA) rV1Optional[Union[str, pathlib.PurePath, IO[bytes]]]rWrlr\r[rXr[rYrrzUnion[bytes, str, Graph])NrNN)rhr@rVrrWrlr\r[rXr[rYrrzUnion[bytes, str, _GraphT])rraN)rWrlrXrlrzzOptional[TextIO]rrNNNNNNr}MOptional[Union[IO[bytes], TextIO, InputSource, str, bytes, pathlib.PurePath]]r~r[rWr[rpr[rcz!Optional[Union[BinaryIO, TextIO]]rzOptional[Union[str, bytes]]rYrrrA)sparqlrNNT)rzUnion[str, Query]rzUnion[str, query.Processor]rzUnion[str, Type[query.Result]]rOptional[Mapping[str, Any]]r"Optional[Mapping[str, Identifier]]rrWrrrz query.Result)rNNT)rzUnion[Update, str]rz(Union[str, rdflib.query.UpdateProcessor]rr rr rrWrrrrrkrrrlrz8Tuple[Type[Graph], Tuple[Store, _ContextIdentifierType]])rz Set[Node])rjr2rr)rjzUnion[Node, str]rr%)rrAr8z$Callable[[_TripleType], _TripleType]rrNNNN) rOptional[Graph]rzOptional[BNode]rr[rr[rrANN)rrrzOptional[URIRef]rrA)rr2rrrrA)Or| __module__ __qualname____doc____annotations__r`propertyrirjrksetterryr}rrrrrrrrrrrrrrrrrrrrrrrrrrrr__or____and__rrrrrrrrr"rr5r7r?rCrErHrrrQrZryrrrr{rrrrrrrrrr __classcell__rms@rnrArAs^ <| $-CG8<"/7 # #A#6 #  # - #4!!((&&L.   8Y 1"1 ,11 5&5 055 =#= 8== !#! 8!"EN20 % P - -    / FGO *8B B0+/ ! (  , (+"% &      +."% '      .1"% ,      +..1(+"% ',&      +/.1ii(,"& ?'?,?& ?  ?  ? ?B(.2 <;<<+ <DAE ',>  7 2@D +&=  6 *1C          8$ >        !      !       !"% <      JM!"% 'F'' '  '  ' "''JN""& IIFII I  I  I $IZ $          "& $"&26,0O O  O  O O0O*OO Oh2:19.2;?#'@U'@U/@U/ @U , @U 9 @U!@U@U @UJ?G.2;?#' 2O)2O<2O, 2O 9 2O ! 2O2O 2OhP *#J ,(**  #G  &*!%#'"& #"##! #  #  #LMQ)()9I) )XJN9$97F9 9roceZdZUdZded< d" d#fd Zd$dZe d% d&dZe d% d'dZe d% d(dZe d% d)d Ze d% d*d Ze d% d+d Z d% d+d Zd,d Z d-dZ ed.dZ ed/dZ d0dZ d1dZ d-dZ e d2 d3dZe d2 d4dZe d2 d5dZ d6 d5dZ d6 d7dZ d6 d8dZd9dZ d6 d:dZd;dZ d< d=dZd>dZd6d?dZ d@ dAd ZdBd!ZxZS)CrDaA ConjunctiveGraph is an (unnamed) aggregation of all the named graphs in a store. .. warning:: ConjunctiveGraph is deprecated, use :class:`~rdflib.graph.Dataset` instead. It has a ``default`` graph, whose name is associated with the graph throughout its life. :meth:`__init__` can take an identifier to use as the name of this default graph or it will assign a BNode. All methods that add triples work against this default graph. All queries are carried out against the union of all graphs. r5rc2tt| ||t|turt j dt d|jjsJdd|_d|_ t|j|xs t||_ y)N)rjz4ConjunctiveGraph is deprecated, use Dataset instead.) stacklevelz9ConjunctiveGraph must be backed by a context aware store.Trirjr\) r_rDr`rxwarningswarnDeprecationWarningrirXrZrAr(r)rhrirjdefault_graph_baserms rnr`zConjunctiveGraph.__init__s .u.L :) ) MMF"  zz'' J '"!-2**)>uwEW. rocLd}||jjjzS)NzK[a rdflib:ConjunctiveGraph;rdflib:storage [a rdflib:Store;rdfs:label '%s']]rirmr|rhpatterns rnr}zConjunctiveGraph.__str__s) 0 --6666rocyrqrrhtriple_or_quadr s rn_spoczConjunctiveGraph._spocs rocyrqrr(s rnr*zConjunctiveGraph._spoc  rocyrqrr(s rnr*zConjunctiveGraph._spocs 47rocyrqrr(s rnr*zConjunctiveGraph._spocs rocyrqrr(s rnr*zConjunctiveGraph._spocr,rocyrqrr(s rnr*zConjunctiveGraph._spocr,roc|ddd|r |jfSdfSt|dk(r|r |jnd}|\}}}n&t|dk(r|\}}}}|j|}fS)z_ helper method for having methods that support either triples or quads N)rr_graph)rhr)r rrrrs rnr*zConjunctiveGraph._spocs  !$gd&:&:P P4P P ~ ! #(/$$TA&IQ1  A %)LQ1a AA!Qzroch|j|\}}}}|j|||f|D]}yy)z)Support for 'triple/quad in graph' syntaxrTF)r*r)rhr)rrrrrs rnrzConjunctiveGraph.__contains__s;ZZ/ 1aq!Qi3A4roc|j|d\}}}}t||||jj|||f|d|S)zu Add a triple or quad to the store. if a triple is given it is added to the default context Tr F)rr)r*rrirrhr)rrrrs rnrzConjunctiveGraph.addsMZZZ= 1aAq! 1ay!E: rocyrqrrhrs rnr4zConjunctiveGraph._graph+sMProcyrqrr:s rnr4zConjunctiveGraph._graph.s'*rocN|yt|ts|j|S|Srq)rbrA get_contextr:s rnr4zConjunctiveGraph._graph1s, 9!U###A& &HrocPjjfd|DS)z&Add a sequence of triples with contextc3nK|],\}}}}t|||s|||j|f.ywrq)rr4rs rnrz(ConjunctiveGraph.addN..@s; 8=*!Q1QPQSTAUQ1dkk!n %s55rirrs` rnrzConjunctiveGraph.addN;s)  8=   rocr|j|\}}}}|jj|||f||S)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)r*rirr8s rnrzConjunctiveGraph.removeFs<ZZ/ 1a 1a)Q/ rocyrqrrhr)rs rnrzConjunctiveGraph.triplesTs .1rocyrqrrCs rnrzConjunctiveGraph.triples[s 25rocyrqrrCs rnrzConjunctiveGraph.triplesbs :=roc#K|j|\}}}}|j|xs|}|jr||jk(rd}n| |j}t |t r'||}|j |||D] \}}|||fy|jj|||f|D]\\}}}}|||fyw)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*r4rZrrbr$rrir)rhr)rrrrrrs rnrzConjunctiveGraph.triplesisZZ/ 1a++gl+   $..... a w1-1Ag ."&!3!3Q1Iw!3!O Aq2Ag "PsCCc#K|j|\}}}}|jj|||f|D]\\}}}}|D] }||||f yw)z:Iterate over all the quads in the entire conjunctive graphrN)r*rir)rhr)rrrrrctxs rnrzConjunctiveGraph.quadsse ZZ/ 1a!ZZ//Aq 1/EMIQ1rAsl"FsAAc#K|\}}}||js|j}n|j|}|jj |||f|D]\\}}}} |||fyw)z` documentation. *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. :attr:`ConjunctiveGraph.default_context`). r|)r~rW)r#rr) rhr}r~rWrprcrrYrs rnrzConjunctiveGraph.parsesMb%  "&& fGxG$Groc>t|j|jffSrq)rDrirjrrs rnrzConjunctiveGraph.__reduce__" s$**doo!>>>ro)r NN)rirrjz$Optional[Union[IdentifiedNode, str]]r"r[rr)r)rOr rWrrO)r)z%Union[_TripleType, _OptionalQuadType]r rWrr7)r)rr rWrz(Tuple[None, None, None, Optional[Graph]])r)"Optional[_TripleOrQuadPatternType]r rWrr:)r)rTr rWrr>)r)z#Optional[_TripleOrQuadSelectorType]r rWrr>r)rTrrW)rhrCr)rPrrC)rz)Union[Graph, _ContextIdentifierType, str]rrA)rrrr)rz3Optional[Union[Graph, _ContextIdentifierType, str]]rr)rhrCrrrrC).)r)rSrrrr)r)rRrrrr)r)rTrrrrrq)r)rZrz(Generator[_OptionalQuadType, None, None]rrrzOptional[_TripleType]rz#Generator[_ContextType, None, None])rjr8rzUnion[Graph, None])FN)rjrrrWr\r[rrA)rr5rr)rrlrWr[rr/rrr )r|rrrrr`r}rr*rrr4rrrrrrr/rPr=rSrWrrrrs@rnrDrDs "!$-;?,0    9 *  07!    =      777 2 77 :    1       ;      ;  * 1 $PP **D  )<  +.101(1 , 11 +.545(5 0 55 +.=1=(= 8 ==+/1( 8 DDH #@ # 1 #+/!( , "$ /30+0 ,0"M"  @      "7, "& $"&26,0E E  E  E E0E*EE EN?rozurn:x-rdflib:defaultc eZdZdZ d dfd ZddZddZddZ ddZ d ddZ d ddZ dd Z dd Z d dfd Z e Z d dfd Z dd ZxZS)rFa 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 `_: .. 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 :class:`rdflib.term.URIRef` or :class:`rdflib.term.BNode` identifiers and always creats a default graph with the :class:`rdflib.term.URIRef` identifier :code:`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. .. note:: 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: >>> # 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) ... versionadded:: 4.0 ctt| |d|jjs t dt |jt||_||_ y)N)rirjz.DataSet must be backed by a graph-aware store!r) r_rFr`ri graph_aware ExceptionrADATASET_DEFAULT_GRAPH_IDrrZ)rhrirZr"rms rnr`zDataset.__init__ sV gt%Ed%Czz%%LM M$**/#  +rocLd}||jjjzS)NzB[a rdflib:Dataset;rdflib:storage [a rdflib:Store;rdfs:label '%s']]r$r%s rnr}zDataset.__str__ s' S --6666rocHt||j|jffSrq)rxrirZrrs rnrzDataset.__reduce__ s T TZZ););<==roc^|j|j|j|jfSrqrirjrrZrrs rn __getstate__zDataset.__getstate__ s%zz4??D,@,@$BTBTTTroc:|\|_|_|_|_yrqre)rhstates rn __setstate__zDataset.__setstate__ s QVM DOT%94;Mroc|7ddlm}m}|jd||zdt j }|j |}||_|jj||S)Nr)_SKOLEM_DEFAULT_AUTHORITYrdflib_skolem_genidgenidF)rL) rdflib.termrkrlrr(rr4r\ri add_graph)rhrjr\rkrlgs rngraphz Dataset.graph sk   R II),??   **,J KK # Qroc `tj|||||||fi|}|j||S)a Parse an RDF source adding the resulting triples to the Graph. See :meth:`rdflib.graph.Graph.parse` for documentation on arguments. 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_context`). .. 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 :doc:`Security Considerations ` documentation. *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. :attr:`.Dataset.default_context`). )rDrrq) rhr}r~rWrprcrrYrs rnrz Dataset.parse s>Z  " " &(FHdD DH  1 roc$|j|S)zalias of graph for consistency)rqrhrps rnrozDataset.add_graph2 szz!}roct|ts|j|}|jj ||||j k(r%|jj |j |Srq)rbrAr=ri remove_graphrrorts rnrvzDataset.remove_graph8 sa!U#  #A " 9T111 JJ !5!5 6 roc#Kd}tt| |D]}||jtk(z}||s|j tyywr^)r_rFr/rjrarq)rhrr rrms rnr/zDataset.contextsE sWw.v6A q||'?? ?GG7**56 6sAAc#Ktt| |D];\}}}}|j|jk(r |||df*||||jf=ywrq)r_rFrrjr)rhquadrrrrrms rnrz Dataset.quadsR s\ 4T:JAq!Q||t333Atm#Aq||++ ;sAAc$|jdS)z$Iterates over all quads in the storer )rrrs rnrzDataset.__iter__^ szz233ro)r FN)rirrZrWr"r[r)rz(Tuple[Type[Dataset], Tuple[Store, bool]])r8Tuple[Store, _ContextIdentifierType, _ContextType, bool])rhr{rrr)rj:Optional[Union[_ContextIdentifierType, _ContextType, str]]r\r[rrArr)rpr|rrA)rhrErpr|rrErqr\)ryrZr2Generator[_OptionalIdentifiedQuadType, None, None])rr})r|rrrr`r}rrfrirqrrorvr/graphsrrrrs@rnrFrF) smWv$-#,0 + ++* +$7>UVMV VRV"N  2 "& $"&26,01 1  1  1 101*11 1fK   V   /37+7 ,7F:> ,6 , ; ,4 ;4rocVeZdZdZ dfd Zd dZd dZd d dZd dZddZ 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. c.tt| ||yrq)r_rHr`)rhrirjrms rnr`zQuotedGraph.__init__m s k4)%. sO # 1a![) /Aq!$ 1aL#rr@rs` rnrzQuotedGraph.addN~ s)  #   roc@d|jj|zS)rz{%s}rrrs rnr{zQuotedGraph.n3 rroc|jj}|jjj}d}|||fzS)NzK{this rdflib.identifier %s;rdflib:storage [a rdflib:Store;rdfs:label '%s']})rjr{rirmr|)rhrjlabelr&s rnr}zQuotedGraph.__str__ sE__'')  $$-- 0 *e,,,roc>t|j|jffSrq)rHrirjrrs rnrzQuotedGraph.__reduce__ sTZZ999ro)rirrjrrrrqr rr ) r|rrrr`rrr{r}rrrs@rnrHrHe s:= =A= P-:rorH c8eZdZdZddZd dZd dZd dZd dZy) 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. c2|tx}|_tttdz}|j |D]E\}}|j |st|j|d}|j||fG|jy)aParameters: - graph: the graph containing the Seq - subject: the subject of a Seq. Note that the init does not check whether this is a Seq, this is done in whoever creates this instance! _rdN) r_listr/rlrr startswithrrMrsort)rhrqrrLI_INDEXrris rnr`z Seq.__init__ s| !V# #c(S.)++G4DAq||H% (B/0 aV$ 5  roc|Srqrrrs rnrz Seq.toPython rroc#<K|jD] \}}| yw)z#Generator over the items in the SeqN)r)rhrrs rnrz Seq.__iter__ szzGAtJ"sc,t|jS)zLength of the Seq)rrrrs rnrz Seq.__len__ s4::rocB|jj|\}}|S)z Item given by index from the Seq)rr)rhindexrs rnrzSeq.__getitem__ sjj,,U3 t roN)rqrArr2)rrI)rrr)rr4) r|rrrr`rrrrrrornrIrI s 4 rorIceZdZddZddZy)rJcyrqrrrs rnr`zModificationException.__init__  roc y)NzZModifications and transactional operations not allowed on ReadOnlyGraphAggregate instancesrrrs rnr}zModificationException.__str__ s  / roNrrrr|rrr`r}rrornrJrJ s   rorJceZdZddZddZy)rKcyrqrrrs rnr`z&UnSupportedAggregateOperation.__init__ rrocy)NzCThis operation is not supported by ReadOnlyGraphAggregate instancesrrrs rnr}z%UnSupportedAggregateOperation.__str__ sWroNrrrrrornrKrK s  XrorKceZdZdZd d!fd Zd"dZd#dZd$dZd$dZd%d&dZ d'dZ d(d Z d)d Z d(d Z e d*d Ze d+d Ze d,dZ d,dZd-dZ d.dZd/dZd$dZd/dZd0dZd0dZ d1 d2dZd3dZd4d5dZ d4 d6dZd7dZd8d9dZ d: d;dZd1d)rr~rrs rnryzReadOnlyGraphAggregate.__repr__ s4s4;;7GGGroctrqrJrs rnrzReadOnlyGraphAggregate.destroy #%%roctrqrrrs rnrzReadOnlyGraphAggregate.commit rroctrqrrrs rnrzReadOnlyGraphAggregate.rollback rrocL|jD]}|j|||yrq)r~r)rhrrrqs rnrzReadOnlyGraphAggregate.open s"[[E JJt]F 3 !rocF|jD]}|jyrq)r~r)rhrqs rnrzReadOnlyGraphAggregate.close s[[E KKM!roctrqrrs rnrzReadOnlyGraphAggregate.add rroctrqrrs rnrzReadOnlyGraphAggregate.addN rroctrqrrs rnrzReadOnlyGraphAggregate.remove rrocyrqrrs rnrzReadOnlyGraphAggregate.triples# rrocyrqrrs rnrzReadOnlyGraphAggregate.triples) rrocyrqrrs rnrzReadOnlyGraphAggregate.triples/ rroc#K|\}}}|jD]Y}t|tr#|j|||D] \}}|||f6|j |||fD] \}}}|||f[ywrq)r~rbr$rr) rhrrrrrqrJrKrLs rnrzReadOnlyGraphAggregate.triples5 s~1a[[E!T"FF4A.DAqQ'M/#(--Aq ":JBBb"*$#; !sA0A2cd}t|dk(r|d}|jD]'}||j|jk(s|dd|vs'yy)Nr3r2TF)rr~rj)rhr)rrqs rnrz#ReadOnlyGraphAggregate.__contains__B s[ ~ ! #$Q'G[[E%"2"2g6H6H"H!"1%.!roc#XKd}t|dk(r|\}}}}n|\}}}|K|jDcgc] }||k(s | c}D]'}|j|||fD]\}} } || | |f)y|jD]'}|j|||fD]\}} } || | |f)ycc}ww)z8Iterate over all the quads in the entire aggregate graphNr3)rr~r) rhr)rrrrrprqrJrKrLs rnrzReadOnlyGraphAggregate.quadsN s  ~ ! #'JAq!Q%GAq! =%)[[;[AF![;"'--Aq ":JBBb"e++#;<"'--Aq ":JBBb"e++#;% .h s/;a3q6;s)sumr~rrs rnrzReadOnlyGraphAggregate.__len__g s/4;;///roctrqrKrrs rnrzReadOnlyGraphAggregate.__hash__j +--roc|yt|tryt|tr3|j|jkD|j|jkz Sy)Nr)rbrArLr~rs rnrzReadOnlyGraphAggregate.__cmp__m sJ = u % 5 6KK%,,.4;;3MN Nroctrqrrs rnrzReadOnlyGraphAggregate.__iadd__w rroctrqrrs rnrzReadOnlyGraphAggregate.__isub__z rroc#K|\}}}|jD](}|j|||f}|D] \}} } || | f*ywrq)r~r) rhrrrrrrqchoicesrrrs rnrz&ReadOnlyGraphAggregate.triples_choices sV '-#G[[E++Wi,IJG"1aAg # !r=c|t|dr'|jr|jj|StNrk)rhrkrErKrFs rnrEzReadOnlyGraphAggregate.qname s5 4, -$2H2H))//4 4+--roc~t|dr(|jr|jj||Str)rhrkrHrKrIs rnrHz$ReadOnlyGraphAggregate.compute_qname s7 4, -$2H2H))77XF F+--roctrqr)rhrrNrLs rnrzReadOnlyGraphAggregate.bind s ,--roc#Kt|dr)|jjD] \}}||f y|jD] }|jD] \}}||f "ywr)rhrkrr~)rhrrNrqs rnrz!ReadOnlyGraphAggregate.namespaces sn 4, -%)%;%;%F%F%H! i''&I).)9)9);%FI )++*<%sA&A(ctrqrrRs rnrQz!ReadOnlyGraphAggregate.absolutize rroc trqr)rhr}r~rWrYs rnrzReadOnlyGraphAggregate.parse s $%%roctrqrrs rnr{zReadOnlyGraphAggregate.n3 rroctrqrrrs rnrz!ReadOnlyGraphAggregate.__reduce__ rror7)r~z List[Graph]rizUnion[str, Store]r)rrlrr)rrr)rrlrrWrrr)rrPrr)rrrrrrrr[)r)rTrzbGenerator[Tuple[_SubjectType, Union[Path, _PredicateType], _ObjectType, _ContextType], None, None]r)rhr@rrrrrqrrrr)rr[rNrrLrWrrrr)rrlrSrrrr) r}rr~r[rWr[rYrrr)rkrrr)!r|rrrr`ryrrrrrrrrrrrrrrrrrrrErHrrrQrr{rrrs@rnrLrL s H&&&4&&&1"1 ,11 5&5 055 =#= 8== %# % 8 % ,7, ,20.&&+/ ! (  , . .GK.#.03.?C. . ,.#' $ &  &  &  & &  &..rorLcyrqrtermss rnrr s36rocyrqrrs rnrr s&)rocH|D]}t|trJd|dy)NzTerm rT)rbr-)rrs rnrr s' !T"K$KK" rocJeZdZdZd d dZd dZ d dZd dZd dZddZ y)rMa) Wrapper around graph that turns batches of calls to Graph's add (and optionally, addN) into calls to batched calls to addN`. :Parameters: - 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 graph: The wrapped graph count: The number of triples buffered since initialization or the last call to reset batch: The current buffer of triples c|r|dkr td||_|f|_||_||_|j y)Nrz$batch_size must be a positive number)r3rq_BatchAddGraph__graph_tuple_BatchAddGraph__batch_size_BatchAddGraph__batch_addnreset)rhrq batch_size batch_addns rnr`zBatchAddGraph.__init__ sAZ!^CD D #X&& roc"g|_d|_|S)zQ Manually clear the buffered triples and reset the count to zero r)batchcountrrs rnrzBatchAddGraph.reset s')   rocrt|j|jk\r,|jj |jg|_|xj dz c_t|dk(r*|jj ||jz|S|jj ||S)zV Add a triple to the buffer :param triple: The triple to add rr2)rrrrqrrrr)rhr)s rnrzBatchAddGraph.add s tzz?d// / JJOODJJ 'DJ a ~ ! # JJ  nt/A/AA B  JJ  n - roc|jr|D]}|j||S|jj||Srq)rrrqr)rhrqs rnrzBatchAddGraph.addN s>      JJOOE " roc&|j|Srq)rrrs rn __enter__zBatchAddGraph.__enter__ s  rocZ|d&|jj|jyy)Nr)rqrr)rhexcs rn__exit__zBatchAddGraph.__exit__ s$ q6> JJOODJJ ' roN)iF)rqrArrrrW)rrM)r)zUnion[_TripleType, _QuadType]rrM)rrrrMr) r|rrrr`rrrrrrrornrMrM s9$   0(rorM)rr-rzte.Literal[True])rrrrW)zr __future__rloggingrjrriortypingrrrrr r r r r rrrrrrrrrrr urllib.parserurllib.requestrrdflib.exceptionsr*rdflib.namespacerN rdflib.pluginrc rdflib.queryr rdflib.utilrrdflib.collectionrrrrr rdflib.parserr!r"r# rdflib.pathsr$rdflib.resourcer%rdflib.serializerr& rdflib.storer'rnr(r)r*r+r,r-r.r/typing_extensionsterdflib.plugins.sparql.sparqlr0r1r2r3r4r8r6rOr7rPrNr9r;r:r<rSrRr=r>rTr?rQrr@rCrErdflib._type_checkingrG getLoggerr|r__all__rUrAr5rDrarFrHterm _ORDERINGrIr`rJrKrLrrMrrornrswr# ,"'&$()==BB$(   ":  'CD Q R $mXn5MM""DE#$mX>V5WW ^h'78(=:QQx7x ?VVW ^  ] ^  ^ ] ^ !!IJ$%UV ^ U+ ,- ]  ^ U+ ,- ] ^ ""LMm;< @A $| h~68M MN (< $~"68M MN (< (>":D