kÿaoE"ddlmZmZmZmZmZmZmZmZm Z m Z ddl Z ddl m Z ddlZddlmZmZddlmZmZmZmZddlZddlmZmZmZmZmZddlmZddlm Z dd l!m"Z"dd l#m$Z$m%Z%dd lm&Z&dd l'm(Z(dd l)m*Z*ddl+Zddl,m-Z-ddl.Z.ddl/Z/ddl0Z0ddl1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7esJesJe j8e9Z:eeefZ;e eeeee;fZGddeZ?Gdde?Z@edZAGdde@ZBGdde?ZCdejDjEeC<GddeFZGGd d!eHZIGd"d#eHZJGd$d%e@ZKd&ZLGd'd(eFZMd)ZNe9d*kr eNdSdS)+) IOAnyIterableOptionalUnionTypecastoverload GeneratorTupleN)warn) NamespaceRDF)plugin exceptionsquery namespace)BNodeNodeURIRefLiteralGenid)Path)Store) Serializer)Parsercreate_input_source)NamespaceManager)Resource Collection) ParserError)BytesIO)urlparse) url2pathnamea % RDFLib defines the following kinds of Graphs: * :class:`~rdflib.graph.Graph` * :class:`~rdflib.graph.QuotedGraph` * :class:`~rdflib.graph.ConjunctiveGraph` * :class:`~rdflib.graph.Dataset` Graph ----- An RDF graph is a set of RDF triples. Graphs support the python ``in`` operator, as well as iteration and some operations like union, difference and intersection. see :class:`~rdflib.graph.Graph` Conjunctive Graph ----------------- A Conjunctive Graph is the most relevant collection of graphs that are considered to be the boundary for closed world assumptions. This boundary is equivalent to that of the store instance (which is itself uniquely identified and distinct from other instances of :class:`Store` that signify other Conjunctive Graphs). It is equivalent to all the named graphs within it and associated with a ``_default_`` graph which is automatically assigned a :class:`BNode` for an identifier - if one isn't given. see :class:`~rdflib.graph.ConjunctiveGraph` Quoted graph ------------ The notion of an RDF graph [14] is extended to include the concept of a formula node. A formula node may occur wherever any other kind of node can appear. Associated with a formula node is an RDF graph that is completely disjoint from all other graphs; i.e. has no nodes in common with any other graph. (It may contain the same labels as other RDF graphs; because this is, by definition, a separate graph, considerations of tidiness do not apply between the graph at a formula node and any other graph.) This is intended to map the idea of "{ N3-expression }" that is used by N3 into an RDF graph upon which RDF semantics is defined. see :class:`~rdflib.graph.QuotedGraph` Dataset ------- The RDF 1.1 Dataset, a small extension to the Conjunctive Graph. The primary term is "graphs in the datasets" and not "contexts with quads" so there is a separate method to set/retrieve a graph in a dataset and to operate with dataset graphs. As a consequence of this approach, dataset graphs cannot be identified with blank nodes, a name is always required (RDFLib will automatically add a name if one is not provided at creation time). This implementation includes a convenience method to directly add a single quad to a dataset graph. see :class:`~rdflib.graph.Dataset` Working with graphs =================== Instantiating Graphs with default store (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("http://rdflib.net")) >>> g.identifier rdflib.term.URIRef('http://rdflib.net') >>> str(g) # doctest: +NORMALIZE_WHITESPACE " a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label '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("http://rdflib.net/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('http://rdflib.net/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('http://rdflib.net/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('http://rdflib.net/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("http://rdflib.net/") >>> RDFLib.ConjunctiveGraph rdflib.term.URIRef('http://rdflib.net/ConjunctiveGraph') >>> RDFLib["Graph"] rdflib.term.URIRef('http://rdflib.net/Graph') ) GraphConjunctiveGraph QuotedGraphSeqModificationExceptionDatasetUnSupportedAggregateOperationReadOnlyGraphAggregate BatchAddGraphceZdZdZ dldeeefdeeeefdee deeffd Z d Z e e Z d Ze eZd Zd Ze eed ZdZdZdZdZdZdZdmdZdmdZdeeeeffdZdeeeeeeffdZdZ deeeede!efeeffdZ"dZ#dZ$d Z%d!Z&d"Z'd#Z(d$Z)d%Z*d&Z+d'Z,d(Z-d)Z.d*Z/d+Z0d,Z1d-Z2d.Z3e0Z4e1Z5d/Z6dnd0eefd1Z7dnd0eefd2Z8dnd0eefd3Z9dod4Z:dod5Z;dod6Zj?ddd8fd9Z?dpd;Z@ddeAjBjCeAjDj@ffd<ZEdpd=ZFd>ZGdod?ZHdod@ZIdodAZJdBZKdCZLdqdDZMdrdEZNdFZOdsdHZPeQdIddJedeedKed0eRf dLZSeQ dtdIddJedeedKed0eRf dNZSeQ dudIddJedeedKdd0ef dOZSeQ dtdIeeeTjUeVeRfdJedeedKeed0df dPZSeQ dudIeeeeTjUeVeRfdJedeedKeed0eeRedff dQZS dvdIeeeeTjUeVeRfdJedeedKeedSed0eeRedff dTZSdwdVZW dxdJeedWeeeeReXffdXZYdydZZZ dzd\eee[j\fd]eee]e[j^fd^e_d0e[j^fd_Z[ d{d`Z`daZadbZbdcZcddZddeZedfZfdgZgdhZhd|diZidndjZjdkZkxZlS)}r&awAn RDF Graph The constructor accepts one argument, the "store" that will be used to store the graph data (see the "store" package for stores currently shipped with rdflib). Stores can be context-aware or unaware. Unaware stores take up (some) less space but cannot support features that require context, such as true merging/demerging of sub-graphs and provenance. The Graph constructor can take an identifier which identifies the Graph by name. If none is given, the graph is assigned a BNode for its identifier. For more on named graphs, see: http://www.w3.org/2004/03/trix/ defaultNstore identifiernamespace_managerbasectt|||_||p t |_t |jtst|j|_|t |ts*tj |tx|_ }n||_ ||_ d|_d|_d|_dSNF)superr&__init__r4r_Graph__identifier isinstancerrrrget _Graph__store_Graph__namespace_manager context_aware formula_aware default_union)selfr1r2r3r4 __class__s ./usr/lib/python3/dist-packages/rdflib/graph.pyr8zGraph.__init__Gs eT##%%%  &1%''$+T22 : &t'8 9 9D  %'' !#;6:eU#;#;#=#= =DL55 DL#4 """c|jSN)r<rAs rC __get_storezGraph.__get_store_s |rDc|jSrF)r9rGs rC__get_identifierzGraph.__get_identifierds   rDcF|jt||_|jSrF)r=rrGs rC_get_namespace_managerzGraph._get_namespace_manageris$  # +'7'='=D $''rDc||_dSrF)r=)rAnms rC_set_namespace_managerzGraph._set_namespace_managerns#%   rDzthis graph's namespace-manager)docc8d|jdt|dS)Nz)r2typerGs rC__repr__zGraph.__repr__ws/3T KKrDct|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']].)r:r2rn3r1rB__name__rGs rC__str__z Graph.__str__zsf dov . . .##%%%%tz';'D'D'DF F W $-. .rDc|SrFrGs rCtoPythonzGraph.toPython rDc:|j||S)zzGraph.addN..sx  1a!U##  //Aq!$$01aL0///   rD)r<addNrArxs` rCrz Graph.addNsL     #       rDc>|j|||S)zRemove a triple from the graph If the triple does not provide a context attribute, removes the triple from all contexts. context)r<removerArjs rCrz Graph.removes$ FD111 rDc#K|\}}}t|tr&||||D] \}}|||fV dS|j|||f|D]\\}}}}|||fVdS)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)r:revalr<triples)rArjrurvrw_s_ocgs rCrz Graph.tripless1a a   &&q!,,  B!Ri  "&!5!5q!Qi!5!N!N   Aq2Ag   rDcFt|tr|j|j|j}}}|||||||fS||||S||||S||||S|| ||S|| ||S|| ||S|||f|vSt|ttfr||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 NzWYou can only index a graph by a single rdflib term or path, or a slice of rdflib terms.)r:slicestartstopsteprsubject_predicatessubject_objectspredicate_objectssubjects predicatesobjectsrr TypeError)rAitemrurvrws rC __getitem__zGraph.__getitem__sET dE " " j$)TY!qAyQY19||Q1I...qy..q111qy++A...qy--a000}}Q***q!,,,||Aq)))1ayD(( tTl + + ))$// /i rDc8|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. r)r<__len__rGs rCrz Graph.__len__s |##D#111rDc,|dS)z&Iterates over all triples in the storeNNNrrGs rC__iter__zGraph.__iter__%s||.///rDc:||D]}dSdS)z$Support for 'triple in graph' syntaxTFrrs rC __contains__zGraph.__contains__)s)ll6**  F44urDc*t|jSrF)hashr2rGs rC__hash__zGraph.__hash__/sDO$$$rDcz|dSt|tr!|j|jk|j|jkz SdS)Nr:r&r2rAothers rC__cmp__z Graph.__cmp__2sI =2 u % % Oe&66%"22 1rDcLt|to|j|jkSrFrrs rC__eq__z Graph.__eq__?s!%''ODOu?O,OOrDcT|dup$t|to|j|jkSrFrrs rC__lt__z Graph.__lt__Bs/  ue $ $ K5;K)K rDc||kp||kSrFrYrs rC__le__z Graph.__le__Ge|,tu},rDcTt|tr|j|jkp|duSrFrrs rC__gt__z Graph.__gt__Js05%((OT_u?O-O   rDc||kp||kSrFrYrs rC__ge__z Graph.__ge__OrrDcJfd|DS)zKAdd all triples in Graph other to Graph. BNode IDs are not changed.c3,K|]\}}}|||fVdSrFrY)r~rurvrwrAs rCrz!Graph.__iadd__..Us177gaA1aD/777777rD)rrs` rC__iadd__zGraph.__iadd__Rs1 7777777777 rDc:|D]}|||S)zRSubtract all triples in Graph other from Graph. BNode IDs are not changed.)r)rArrjs rC__isub__zGraph.__isub__Xs-  F KK     rDc t|}n#t$rt}YnwxYwtt |t |zD]\}}||||D]}|||D]}|||S)z6Set-theoretic union BNode IDs are not changed.)rRrr&setlist namespacesbindrs)rArretvalprefixurixys rC__add__z Graph.__add___s T$ZZ\\FF   WWFFF  doo&7&7!8!84@P@P@R@R;S;S!STT % %MVS KK $ $ $ $  A JJqMMMM  A JJqMMMM 55c t|}n#t$rt}YnwxYw|D]}||vr|||S)z>Set-theoretic intersection. BNode IDs are not changed.rRrr&rsrArrrs rC__mul__z Graph.__mul__nso 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, *, *))rrs)rArjsubject predicateobject_s rCrz Graph.setsw )/%)W    K    ! ! K " ! ! Wi./// '9g./// rDreturnc#PK|d||fD] \}}}|V dS)z;A generator of subjects with the given predicate and objectNr)rArobjectrurvrws rCrzGraph.subjectssC||T9f$=>>  GAq!GGGG  rDc#PK||d|fD] \}}}|V dS)z;A generator of predicates with the given subject and objectNr)rArrrurvrws rCrzGraph.predicatessC||WdF$;<<  GAq!GGGG  rDc#PK|||dfD] \}}}|V dS)z;A generator of objects with the given subject and predicateNr)rArrrurvrws rCrz Graph.objectssC||Wi$>??  GAq!GGGG  rDc#TK|dd|fD] \}}}||fV dS)z?A generator of (subject, predicate) tuples for the given objectNr)rArrurvrws rCrzGraph.subject_predicatessG||T4$899  GAq!Q$JJJJ  rDc#TK|d|dfD] \}}}||fV dS)z?A generator of (subject, object) tuples for the given predicateNr)rArrurvrws rCrzGraph.subject_objectssG||T9d$;<<  GAq!Q$JJJJ  rDc#TK||ddfD] \}}}||fV dS)z?A generator of (predicate, object) tuples for the given subjectNr)rArrurvrws rCrzGraph.predicate_objectssG||WdD$9::  GAq!Q$JJJJ  rDc#vK|\}}}|j|||f|D]\\}}}} |||fVdS)Nr)r1triples_choices) rArjrrrrrurvrwrs rCrzGraph.triples_choicessk&,#G!Z77 i )48    MIQ1rQ'MMMM  rDTc |}||||||dS||||}||||}||||} t|}|dur t|d|d|d|d}|j|||fd} | D](\\} } } } |d| d| d| dt | d z })tj|#t$rYnwxYwn#t$r|}YnwxYw|S) aGet a value for a pair of two criteria Exactly one of subject, predicate, object must be None. Useful if one knows that there may only be one value. It is one of those situations that occur a lot, hence this 'macro' like utility Parameters: subject, predicate, object -- exactly one must be None default -- value to be returned if no values found any -- if True, return any value in the case there is more than one, else, raise UniquenessError NFz"While trying to find a value for (z, z-) the following multiple values where found: (z) (contexts: z) ) rrrnextr1rrrUniquenessError StopIteration)rArrrr0anyrvaluesmsgrrurvrwcontextss rCvaluez Graph.values"_!2FN!fn4 >\\'955F ?]]9f55F  __Wf55F &\\Fe||LLLL#77IIIvvv7 #j00'9f1MtTTG/6+ Aq8AAAAAA NNNN   %4S999$D#   FFF , s%C7.A8C&& C32C37 DDcttd||S||tjj|dS)z{Query for the RDFS.label of the subject Return default if no label exists or any label if multiple exist. z@graph.label() is deprecated and will be removed in rdflib 6.0.0.NTr0r)r DeprecationWarningrrRDFSlabelrArr0s rCrz Graph.labelsQ R     ?Nzz'9>#7dzSSSrDc &ttd|g}dkrd}n fd}nd}|D]Vtt|||}t |dkrGfd|DcS|S) a Find the preferred label for subject. By default prefers skos:prefLabels over rdfs:labels. In case at least one prefLabel is found returns those, else returns labels. In case a language string (e.g., "en", "de" or even "" for no lang-tagged literals) is given, only such labels will be considered. Return a list of (labelProp, label) pairs, where labelProp is either skos:prefLabel or rdfs:label. >>> from rdflib import ConjunctiveGraph, URIRef, Literal, namespace >>> from pprint import pprint >>> g = ConjunctiveGraph() >>> u = URIRef("http://example.com/foo") >>> g.add([u, namespace.RDFS.label, Literal("foo")]) # doctest: +ELLIPSIS )> >>> g.add([u, namespace.RDFS.label, Literal("bar")]) # doctest: +ELLIPSIS )> >>> pprint(sorted(g.preferredLabel(u))) [(rdflib.term.URIRef('http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Literal('bar')), (rdflib.term.URIRef('http://www.w3.org/2000/01/rdf-schema#label'), rdflib.term.Literal('foo'))] >>> g.add([u, namespace.SKOS.prefLabel, Literal("bla")]) # doctest: +ELLIPSIS )> >>> pprint(g.preferredLabel(u)) [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('bla'))] >>> g.add([u, namespace.SKOS.prefLabel, Literal("blubb", lang="en")]) # doctest: +ELLIPSIS )> >>> sorted(g.preferredLabel(u)) #doctest: +NORMALIZE_WHITESPACE [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('bla')), (rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('blubb', lang='en'))] >>> g.preferredLabel(u, lang="") #doctest: +NORMALIZE_WHITESPACE [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('bla'))] >>> pprint(g.preferredLabel(u, lang="en")) [(rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#prefLabel'), rdflib.term.Literal('blubb', lang='en'))] zIgraph.preferredLabel() is deprecated and will be removed in rdflib 6.0.0.Nrc|jduSrFlanguagel_s rC langfilterz(Graph.preferredLabel..langfilterMs;$..rDc|jkSrFr)rlangs rCrz(Graph.preferredLabel..langfilterRs;$..rDcdS)NTrYrs rCrz(Graph.preferredLabel..langfilterWstrDrcg|]}|fSrYrY)r~r labelProps rC z(Graph.preferredLabel.._s999BB999rD)r rrfilterrlen)rArrr0labelPropertiesrlabelsrs ` @rCpreferredLabelzGraph.preferredLabelsd [     ?G  rzz//// //////    ) : :I&T\\'9-M-MNNOOF6{{a9999&999999rDcttd||S||tjj|dS)z_Query for the RDFS.comment of the subject Return default if no comment exists zBgraph.comment() is deprecated and will be removed in rdflib 6.0.0.NTr)r rrrrcommentrs rCrz Graph.commentbsR T     ?Nzz'9>#97PTzUUUrDc#Kt|g}|rr||tj}||V||tj}||vrt d|||pdSdS)zgGenerator over all items in the resource specified by list list is an RDF collection. Nz,List contains a recursive rdf:rest reference)rrrfirstrest ValueErrorrs)rArchainrs rCitemsz Graph.itemsps TF  ::dCI..D ::dCH--Du}} !OPPP IIdOOO     rDc#K|i}n||vrdSd||<|||D]$}|V||||D]}|V%dS)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)rAfuncargseenrtrt_2s rCr zGraph.transitiveClosures^ <DD D[[ FS $sD//  BHHH..tR>>      rDc#K|i}||vrdSd||<|V|||D] }||||D]}|V!dS)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)rArrrememberrrws rCrzGraph.transitive_objectss  H h   F ll7I66  F,,VYII     rDc#K|i}||vrdSd||<|V|||D] }||||D]}|V!dS)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)rArrrrrus rCrzGraph.transitive_subjectss  H X   F }}Y77  G--i(KK     rDcttd|tjtjf|vrt ||SdS)ziCheck if subject is an rdf:Seq If yes, it returns a Seq class instance, None otherwise. z>graph.seq() is deprecated and will be removed in rdflib 6.0.0.N)r rrrRr))rArs rCseqz Graph.seqsS P     SXsw '4 / /tW%% %4rDc6|j|SrF)r3qnamerArs rCrz Graph.qnames%++C000rDc8|j||SrF)r3 compute_qnamerArgenerates rCrzGraph.compute_qnames%33CBBBrDc>|j||||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)r3r)rArrr!r"s rCrz Graph.binds-%** I'+   rDc#TK|jD] \}}||fV dS)z/Generator over all the prefix, namespace tuplesN)r3r)rArrs rCrzGraph.namespacessG!%!7!B!B!D!D $ $ FI)# # # # # $ $rDrc8|j||S)z5Turn uri into an absolute URI if it's not one already)r3 absolutizerArdefrags rCr%zGraph.absolutizes%00f===rD destinationformatencodingc dSrFrYrAr(r)r4r*argss rC serializezGraph.serializes  rD.c dSrFrYr,s rCr.zGraph.serialize s  rDc dSrFrYr,s rCr.zGraph.serialize  rDc dSrFrYr,s rCr.zGraph.serialize&r1rDc dSrFrYr,s rCr.zGraph.serialize2r1rDturtler-c ||j}tj|t|}|mt }|8|j|f|dd||dS|j|f||d||St|dr3ttt|}|j|f||d|n)t|tjrt|}ntt|}t!|\} } } } } }| dkrt#d|dt%j\}}t)j|d}|j|f||d||| d krt/| n|}tt0d rt1j||n)t1j||t)j||S) aSerialize the Graph to destination If destination is None serialize method returns the serialization as bytes or string. If encoding is None and destination is None, returns a string If encoding is set, and Destination is None, returns bytes Format defaults to turtle. Format support can be extended with plugins, but "xml", "n3", "turtle", "nt", "pretty-xml", "trix", "trig" and "nquads" are built in. Nutf-8)r4r*writerz destination z is not a local file referencewbfilemove)r4rr;rr#r.getvaluedecodehasattrr rbytesr:pathlibPurePathstrr$rtempfilemkstemposfdopenrir%shutilr:copyr)rAr(r)r4r*r- serializerstreamlocationschemenetlocpathparams_queryfragmentfdnamedests rCr.zGraph.serialize=s-. <9D3VZ 33D99  YYF$ $VQ$QQDQQQ((//888$ $VR$RRTRRR((( ; ( ( "U)[11F J  NdX N N N N N N+w'788 2{++[11=Eh=O=O :FFD&&(|| N;NNN '))HBYr4((F J  NdX N N N N N LLNNN)/6)9)9<%%%xDvv&&  D$'''' D$''' $ rDr6c|t|d||||ddS)N)r)r*T)r9flush)printr.r<)rAr)r*outs rCrVz Graph.printzsL NN4N B B I I( S S      rDdatac dt||||||}||j}d}|tt|dr^t|jddrHt |jjtr)tj |jj}|d}d}tj |t} | j||fi|n(#t$r} |rt!d|z| d} ~ wwxYw |jr|n!#|jr|wwxYw|S) a Parse an RDF source adding the resulting triples to the Graph. The source is specified using one of source, location, file or data. :Parameters: - `source`: An InputSource, file-like object, or string. In the case of a string the string is the location of the source. - `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. - `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. - `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). :Returns: - self, the graph instance. Examples: >>> my_data = ''' ... ... ... Example ... This is really just an example. ... ... ... ''' >>> import tempfile >>> fd, file_name = tempfile.mkstemp() >>> f = os.fdopen(fd, "w") >>> dummy = f.write(my_data) # Returns num bytes written >>> 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 sourcepublicIDrJr9rXr)NFr9rRr4TzCould 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_typer=getattrr9r:rRrArdflibutil guess_formatrr;rparse SyntaxErrorr" auto_closeri) rAr[r\r)rJr9rXr-could_not_guess_formatparserses rCrbz Graph.parsesb%     >(F!& >'' DFK66 Dv{/55 D  11&+2BCC~!)-&+FF++--  FL . . . . . .   % !S   /        s*:C D C/C**C//DD-xmlchttd||||S)Nzagraph.load() is deprecated, it will be removed in rdflib 6.0.0. Please use graph.parse() instead.)r rrb)rAr[r\r)s rCloadz Graph.loads> 4     zz&(F333rDsparql processorresultuse_store_providedc 6|pi}|p t|}t|jdr7|r5 |jj||||jrdp|jfi|S#t$rYnwxYwt|tj s2tj tt|tj }t|tjs(tj |tj|}||j|||fi|S)ap Query this graph. A type of 'prepared queries' can be realised by providing initial variable bindings with initBindings Initial namespaces are used to resolve prefixes used in the query, if none are given, the namespaces from the graph's namespace manager are used. :returntype: rdflib.query.Result r __UNION__)dictrr=r1rr@r2NotImplementedErrorr:Resultrr;r rA Processor)rA query_objectrlrminitNs initBindingsrnkwargss rCrz Graph.querys>0$)r 24 1 122 4:w ' ' ,>  'tz'  &6;I$/   '    &%,// AZS& 1 15<@@F)U_55 E> 9eo>>tDDIvoiolL&SSFSSTTT#A$$ A10A1c |pi}|p t|}t|jdr7|r5 |jj||||jrdp|jfi|S#t$rYnwxYwt|tj s(tj |tj |}|j|||fi|S)z.Update this graph with the given update query.updaterp) rqrr=r1r{r@r2rrr:rUpdateProcessorrr;)rA update_objectrlrvrwrnrxs rCr{z Graph.update0s$)r 24 1 122 4:x ( ( -?  (tz(! &6;I$/   '    )U%:;; KD 9e.CDDTJJIy |VNNvNNNryc:d|jzS)%Return an n3 identifier for the Graphz[%s]r2rUrGs rCrUzGraph.n3N**,,,,rDc,t|j|jffSrF)r&r1r2rGs rC __reduce__zGraph.__reduce__Rs     rDc>t|t|krdS|D]:\}}}t|tst|ts |||f|vrdS;|D]:\}}}t|tst|ts |||f|vrdS;dS)z does a very basic check if these graphs are the same If no BNodes are involved, this is accurate. See rdflib.compare for a correct implementation of isomorphism checks FT)rr:r)rArrurvrws rC isomorphiczGraph.isomorphic[s t99E " "5 ! !GAq!a'' ! 1e0D0D !1ayE)) 55 ! !GAq!a'' ! 1e0D0D !1ayD(( 55trDc"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. 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)rT) r all_nodesrandom randrangerpopappendrr)rAr discoveredvisitingrnew_xs rC connectedzGraph.connectedps8))**   5f.s9~~>>?@ + A ""!!!$$$a00 + + **uH/D/DOOE***a00 + + **uH/D/DOOE*** + y>>S__ , ,45rDct|}|||SrF)rrr{r)rAress rCrzGraph.all_nodess6$,,..!! 4==??### rDc"t||S)aCreate a new ``Collection`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> collection = graph.collection(uri) >>> assert isinstance(collection, Collection) >>> assert collection.uri is uri >>> assert collection.graph is graph >>> collection += [ Literal(1), Literal(2) ] r rAr2s rC collectionzGraph.collections$$ +++rDcjt|tst|}t||S)aCreate a new ``Resource`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> resource = graph.resource(uri) >>> assert isinstance(resource, Resource) >>> assert resource.identifier is uri >>> assert resource.graph is graph )r:rrrrs rCresourcezGraph.resources3"*d++ , ++Jj)))rDcr|dD] }|||!dS)Nr)rrs)rAtargetr ts rC_process_skolem_tupleszGraph._process_skolem_tuplessE011  A JJttAww      rDcfdfd}|tn|}|||n/ttr||fd|S)Nc|\}}}||kr|}||kr|}|||fSN) authoritybasepath) skolemize)bnoderrurvrwrrs rC do_skolemizez%Graph.skolemize..do_skolemizesUIQ1EzzKK)hKGGEzzKK)hKGGa7NrDc|\}}}t|tr|}t|tr|}|||fSr)r:rr)rrurvrwrrs rC do_skolemize2z&Graph.skolemize..do_skolemize2siIQ1!U## HKK)hKGG!U## HKK)hKGGa7NrDc|SrFrY)rrrs rCz!Graph.skolemize..s,,ua:P:PrD)r&rr:r)rA new_graphrrrrrrs ``` @rCrzGraph.skolemizes            &-9 =  ' ' > > > > u % % R  ' '0P0P0P0P0P Q Q Q rDcdd}|tn|}|||n/ttr||fd|S)Nc|\}}}||kr|}||kr|}|||fSrF) de_skolemize)urirefrrurvrws rCdo_de_skolemizez+Graph.de_skolemize..do_de_skolemizesHIQ1F{{NN$$F{{NN$$a7NrDc|\}}}t|tr|}t|tr|}|||fSrF)r:rr)rrurvrws rCdo_de_skolemize2z,Graph.de_skolemize..do_de_skolemize2sZIQ1!U## %NN$$!U## %NN$$a7NrDc|SrFrY)rrrs rCrz$Graph.de_skolemize..s//&RS:T:TrD)r&rr:r)rArrrrrs ` @rCrzGraph.de_skolemizes      &-9 >  ' '0@ A A A A  & & V  ' '0T0T0T0T0T U U U rDcLtfd|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 :return: a Graph, subgraph of self c|ddfD]H\}}} |||ft|tkr|ddf vr |Idtj|fD]=\}}}|ddfD]\}}} |||f>dSrF)rrsrRrrr) rrurvrws2p2o2 add_to_cbdrAsubgraphs rCrzGraph.cbd..add_to_cbds<<dD(9:: " "1a aAY'''77e##QdOx,G,GJqMMM <<s{C(@AA / /1a"&,,4"?"?//JBBLL"b"..../ / /rD)r&)rArrrs` @@rCcbdz Graph.cbdsJ:77 / / / / / / /$  8rD)r0NNNFNNrF)rT)TFr)...)....)Nr4NN)r4r6NNNNNNN)Nrh)rkrkNNT)rkNNTNNNN)mrV __module__ __qualname____doc__rrrArrrr8_Graph__get_storepropertyr1_Graph__get_identifierr2rLrOr3rSrWrZr]rarcrerir rsrrrrrrrrrrrrrrrrrrrrrrr__or____and__rrrrrrrrrrrrSKOS prefLabelrrrr r rrrrrrrr%r r>r.r?r@rrV bytearrayrbrjrrtrrsboolr{rUrrrrrrrrrr __classcell__rBs@rCr&r&4s ($-158<" ##UCZ #U49-.#$$45 # sm ######0 H[ ! !E!!!*++J((( &&&! , LLL...   8888YYYY%dD 01 (5tT3)>#?@    HTNE$d2B,CXd^ST FFFP222000 %%%   PPP   ---   ---          /// FG"x~ x~ x~    cidPT9999v T T T T""19>3GH QQQQf V V V V   7777r    111CCCC     $$$ >>>>   ), 4r@r&rdefault_context)rAr1r2rrBs rCr8zConjunctiveGraph.__init__?s %%..u.LLLz'  J   "!$*)>uwwEW   rDc.d}||jjjzS)NzK[a rdflib:ConjunctiveGraph;rdflib:storage [a rdflib:Store;rdfs:label '%s']]r1rBrVrApatterns rCrWzConjunctiveGraph.__str__Os! 0 -666rDFtriple_or_quadrcdSrFrYrArr0s rC_spoczConjunctiveGraph._spocVs  rDcdSrFrYrs rCrzConjunctiveGraph._spoc`s rDc|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)rArr0rrurvrws rCrzConjunctiveGraph._spochs  !$g&Od&:&:4P P ~  ! # #(/9$$TA&IQ11  A % %)LQ1a AA!QzrDcx||\}}}}||||f|D]}dSdS)z)Support for 'triple/quad in graph' syntaxrTF)rr)rArrurvrwrrs rCrzConjunctiveGraph.__contains__}sLZZ// 1aq!Qi33  A44urDc||d\}}}}t||||j|||f|d|S)zu Add a triple or quad to the store. if a triple is given it is added to the default context Tr0F)rrr)rr|r1rsrArrurvrwrs rCrszConjunctiveGraph.addsXZZZ== 1aAq! 1ay!E::: rDrcdSrFrYrArs rCrzConjunctiveGraph._graph rDcdSrFrYrs rCrzConjunctiveGraph._graphrrDcb|dSt|ts||S|SrF)r:r& get_contextrs rCrzConjunctiveGraph._graphs7 94!U## ##A&& &HrDrxcTjfd|DS)z&Add a sequence of triples with contextc3vK|]3\}}}}t|||||||fV4dSrF)r|rr}s rCrz(ConjunctiveGraph.addN..se  *4!Q1QPQSTAUAU 1dkk!nn %      rDr1rrs` rCrzConjunctiveGraph.addNsJ     8=       rDcx||\}}}}|j|||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)rr1rrs rCrzConjunctiveGraph.removesCZZ// 1a 1a)Q/// rDc#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) rrr@rr:rrr1r)rArrrurvrwrrs rCrzConjunctiveGraph.tripless ZZ// 1a++gl++   /$.... a   w1--  1Ag   "&!3!3Q1Iw!3!O!O   Aq2Ag   rDc#K||\}}}}|j|||f|D]\\}}}}|D] }||||fV dS)z:Iterate over all the quads in the entire conjunctive graphrN)rr1r)rArrurvrwrrctxs rCrxzConjunctiveGraph.quadssZZ// 1a!Z//Aq 1/EE # #MIQ1r # #Asl"""" # # #rDc#K|\}}}||js|j}n||}|j|||f|D]\\}}}} |||fVdS)z Parse source adding the resulting triples to its own context (sub graph of this graph). See :meth:`rdflib.graph.Graph.parse` for documentation on arguments. :Returns: The graph into which the source was parsed. In the case of n3 it returns the root context. rZr1r2r)r\r)) r getPublicIdr:rrr&r1rrb) rAr[r\r)rJr9rXr-g_idrs rCrbzConjunctiveGraph.parses,%    $H<(:(:(<(<$%% $<>>rD)r0NNr)rNrNrF)FNr)"rVrrrrrrArrr8rWr r rrr&rrrsrrrrrrxrrrrrrrbrrrs@rCr'r'1s?  $-15,0   UCZ  U49-. %SM       777     $dHSM1 2E$d:J4K K    tT4%0 1    X      tT4%0 1    X   %dD(3-78%dD@P:QQ R    x~x~x~xN O * %dD$ .M(NPUVZ\`bfVfPg(g"h m     eT3./ E   X    X udC'7!89huo(5tT3)>#?@   :####    $$$ 0 0 0 0""   U49-.    sm       777,,,,  ''''R???????rDr'zurn:x-rdflib:defaultceZdZdZdfd ZdZdZdZd Zdd Z dd Z d Z d Z dfd Z e ZfdZdeeddffdZxZS)r+a? RDF 1.1 Dataset. Small extension to the Conjunctive Graph: - the primary term is graphs in the datasets and not contexts with quads, so there is a separate method to set/retrieve a graph in a dataset and operate with graphs - graphs cannot be identified with blank nodes - added a method to directly add a single quad Examples of usage: >>> # Create a new Dataset >>> ds = Dataset() >>> # simple triples goes to default graph >>> ds.add((URIRef("http://example.org/a"), ... URIRef("http://www.example.org/b"), ... Literal("foo"))) # 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) # doctest: DEFAULT http://www.example.com/gr >>> # A graph can be created without specifying a name; a skolemized genid >>> # is created on the fly >>> h = ds.graph() >>> for c in ds.graphs(): # doctest: +SKIP ... print(c) # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS DEFAULT http://rdlib.net/.well-known/genid/rdflib/N... http://www.example.com/gr >>> # Note that the Dataset.graphs() call returns names of empty graphs, >>> # too. This can be restricted: >>> for c in ds.graphs(empty=False): # doctest: +SKIP ... print(c) # doctest: +NORMALIZE_WHITESPACE DEFAULT http://www.example.com/gr >>> >>> # a graph can also be removed from a dataset via ds.remove_graph(g) .. versionadded:: 4.0 r0FNctt||d|jjst dt |jt||_||_ dS)Nrz.DataSet must be backed by a graph-aware store!r) r7r+r8r1 graph_aware Exceptionr&DATASET_DEFAULT_GRAPH_IDrr@)rAr1r@rrBs rCr8zDataset.__init__su gt%%Ed%CCCz% NLMM M$*/#    +rDc.d}||jjjzS)NzB[a rdflib:Dataset;rdflib:storage [a rdflib:Store;rdfs:label '%s']]rrs rCrWzDataset.__str__s S -666rDc<t||j|jffSrF)rRr1r@rGs rCrzDataset.__reduce__sT TZ);<==rDc6|j|j|j|jfSrFr1r2rr@rGs rC __getstate__zDataset.__getstate__sz4?D,@$BTTTrDc<|\|_|_|_|_dSrFr )rAstates rC __setstate__zDataset.__setstate__s PUM DOT%94;M;M;MrDc|Addlm}|dd|zdt}||}||_|j||S)Nr)rdflib_skolem_genidgenidzhttp://rdflib.netF)r!) rdflib.termrrrrrr4r1 add_graph)rAr2r4rgs rCgraphz Dataset.graphs   7 7 7 7 7 7 II,/BBU    **,,J KK # # QrDc `tj|||||||fi|}|||SrF)r'rbr) rAr[r\r)rJr9rXr-rs rCrbz Dataset.parsesH  " &(FHdD  DH   1 rDc,||S)zalias of graph for consistency)rrArs rCrzDataset.add_graphszz!}}rDct|ts||}|j|| ||jkr|j|j|SrF)r:r&rr1 remove_graphrrrs rCrzDataset.remove_graphso!U## $  ##A """ 9T111 J !5 6 6 6 rDc#Kd}tt||D]}||jtkz}|V|s|tVdSdSr6)r7r+rr2rr)rArjr0rrBs rCrzDataset.contexts sw%%..v66  A q|'?? ?GGGGG 7**566 6 6 6 6 6 7 7rDc#Ktt||D]-\}}}}|j|jkr |||dfV ||||jfV.dSrF)r7r+rxr2r)rAquadrurvrwrrBs rCrxz Dataset.quadss..44T:: , ,JAq!Q|t333Atm####Aq|+++++  , ,rDrc,|dS)z$Iterates over all quads in the storer)rxrGs rCrzDataset.__iter__szz2333rD)r0FNrrrF)rVrrrr8rWrr r rrbrrrgraphsrxr DatasetQuadrrrs@rCr+r+FsGxGt + + + + + +777 >>>UUUVVV    "      777777F,,,,,4)Kt$;<44444444rDr+cveZdZdZfdZdeeeeffdZdeeeeefddfdZ dZ d Z d Z xZ S) r(a Quoted Graphs are intended to implement Notation 3 formulae. They are associated with a required identifier that the N3 parser *must* provide in order to maintain consistent formulae identification for scenarios such as implication and other such processing. cZtt|||dSrF)r7r(r8)rAr1r2rBs rCr8zQuotedGraph.__init__)s) k4  ))%<<<<.9sx  1a![))  //Aq!$$01aL0///   rDrrs` rCrzQuotedGraph.addN6sJ     #       rDc:d|jzS)rz{%s}rrGs rCrUzQuotedGraph.n3BrrDch|j}|jjj}d}|||fzS)NzK{this rdflib.identifier %s;rdflib:storage [a rdflib:Store;rdfs:label '%s']})r2rUr1rBrV)rAr2rrs rCrWzQuotedGraph.__str__Fs>_''))  $- 0 *e,,,rDc,t|j|jffSrF)r(r1r2rGs rCrzQuotedGraph.__reduce__OsTZ999rD)rVrrrr8r rrsrrrUrWrrrs@rCr(r(!s=====%dD 01 %dD# 56 =    ------:::::::rDr( c0eZdZdZdZdZdZdZdZdS)r)a.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. cttx}|_tttdz}||D]T\}}||r:t||d}| ||fU| dS)aParameters: - graph: the graph containing the Seq - subject: the subject of a Seq. Note that the init does not check whether this is a Seq, this is done in whoever creates this instance! _rN) r_listrrArr startswithintr"rsort)rArrr,LI_INDEXrvrwis rCr8z Seq.__init__cs"VV# #c((S.))--g66 % %FQ||H%% % (B//00 aV$$$  rDc|SrFrYrGs rCrZz Seq.toPythonzr[rDc#,K|jD] \}}|V dS)z#Generator over the items in the SeqN)r,)rAr+rs rCrz Seq.__iter__}s0z  GAtJJJJ  rDc*t|jS)zLength of the Seq)rr,rGs rCrz Seq.__len__s4:rDc@|j|\}}|S)z Item given by index from the Seq)r,r)rAindexrs rCrzSeq.__getitem__s j,,U33 t rDN) rVrrrr8rZrrrrYrDrCr)r)Zsi. rDr)ceZdZdZdZdS)r*cdSrFrYrGs rCr8zModificationException.__init__ rDc dS)NzZModifications and transactional operations not allowed on ReadOnlyGraphAggregate instancesrYrGs rCrWzModificationException.__str__s /  rDNrVrrr8rWrYrDrCr*r*s2        rDr*ceZdZdZdZdS)r,cdSrFrYrGs rCr8z&UnSupportedAggregateOperation.__init__r9rDcdS)NzCThis operation is not supported by ReadOnlyGraphAggregate instancesrYrGs rCrWz%UnSupportedAggregateOperation.__str__sWWrDNr;rYrDrCr,r,s7   XXXXXrDr,ceZdZdZd"fd ZdZdZdZdZd#d Z d Z d Z d Z d Z dZdZdZdZdZdZdZdZd$dZdZd%dZd%dZdZd&dZd'dZd Zd!ZxZS)(r-zUtility class for treating a set of graphs as a single graph Only read operations are supported (hence the name). Essentially a ConjunctiveGraph over an explicit subset of the entire store. r0c|Jtt||t||d|_t |t r|r d|Ds Jd||_dS)Nc<g|]}t|t|SrY)r:r&r~rs rCrz3ReadOnlyGraphAggregate.__init__..s';;;qjE&:&:;;;;rDz*graphs argument must be a list of Graphs!!)r7r-r8r&*_ReadOnlyGraphAggregate__namespace_managerr:rr)rArr1rBs rCr8zReadOnlyGraphAggregate.__init__s   ($ / / 8 8 ? ? ? NN4 ' ' ''+D $ vt $ $ 8 8<;F;;; 8 8 8  8 8 8  rDc0dt|jzS)Nz#)rrrGs rCrSzReadOnlyGraphAggregate.__repr__s4s4;7G7GGGrDctrFr*r^s rCr]zReadOnlyGraphAggregate.destroy#%%%rDctrFrFrGs rCrazReadOnlyGraphAggregate.commitrGrDctrFrFrGs rCrczReadOnlyGraphAggregate.rollbackrGrDFcH|jD]}||||dSrF)rre)rAr_rfrs rCrezReadOnlyGraphAggregate.opens6[ 4 4E JJt]F 3 3 3 3 4 4rDcB|jD]}|dSrF)rri)rArs rCrizReadOnlyGraphAggregate.closes,[  E KKMMMM  rDctrFrFrs rCrszReadOnlyGraphAggregate.addrGrDctrFrFrs rCrzReadOnlyGraphAggregate.addNrGrDctrFrFrs rCrzReadOnlyGraphAggregate.removerGrDc#K|\}}}|jD]b}t|tr%||||D] \}}|||fV <||||fD] \}}}|||fVcdSrF)rr:rrr rArjrurvrwrrrrs rCrzReadOnlyGraphAggregate.tripless1a[ % %E!T"" %FF4A..""DAqQ'MMMM"#(--Aq ":":%%JBBb"*$$$$%  % %rDcd}t|dkr|d}|jD]#}||j|jkr|dd|vrdS$dS)NrrTF)rrr2)rArrrs rCrz#ReadOnlyGraphAggregate.__contains__sk ~  ! # #$Q'G[  E%"2g6H"H"H!"1"%..44urDc#xK|\}}}|jD])}||||fD]\}}}||||fV*dS)z8Iterate over all the quads in the entire aggregate graphN)rrrPs rCrxzReadOnlyGraphAggregate.quadssp1a[ ( (E#mmQ1I66 ( ( B"b%''''' ( ( (rDc>td|jDS)Nc34K|]}t|VdSrF)rrBs rCrz1ReadOnlyGraphAggregate.__len__..s(//a3q66//////rD)sumrrGs rCrzReadOnlyGraphAggregate.__len__s!//4;//////rDctrFr,rGs rCrzReadOnlyGraphAggregate.__hash__+---rDc|dSt|trdSt|tr!|j|jk|j|jkz SdS)Nr)r:r&r-rrs rCrzReadOnlyGraphAggregate.__cmp__sX =2 u % % 2 5 6 6 K%,.4;3MN N2rDctrFrFrs rCrzReadOnlyGraphAggregate.__iadd__rGrDctrFrFrs rCrzReadOnlyGraphAggregate.__isub__ rGrDNc#zK|\}}}|jD]*}||||f}|D] \}} } || | fV+dSrF)rr) rArjrrrrrchoicesrurvrws rCrz&ReadOnlyGraphAggregate.triples_choices sr&,#G[  E++Wi,IJJG$   AqAg    rDct|dr!|jr|j|StNr3)r=r3rr,rs rCrzReadOnlyGraphAggregate.qname sB 4, - - 5$2H 5)//44 4+---rDTct|dr"|jr|j||Str_)r=r3rr,rs rCrz$ReadOnlyGraphAggregate.compute_qname sF 4, - - G$2H G)77XFF F+---rDctrFrW)rArrr!s rCrzReadOnlyGraphAggregate.bind rXrDc#Kt|dr'|jD] \}}||fV dS|jD]"}|D] \}}||fV #dSr_)r=r3rr)rArrrs rCrz!ReadOnlyGraphAggregate.namespaces s 4, - - ,%)%;%F%F%H%H ( (! i''''' ( ( , ,).)9)9););,,%FI )+++++, , ,rDrctrFrWr&s rCr%z!ReadOnlyGraphAggregate.absolutize" rXrDc trFrF)rAr[r\r)r-s rCrbzReadOnlyGraphAggregate.parse% rGrDctrFrWrGs rCrUzReadOnlyGraphAggregate.n3( rXrDctrFrWrGs rCrz!ReadOnlyGraphAggregate.__reduce__+ rXrDrrrFrrr) rVrrrr8rSr]rarcrerirsrrrrrxrrrrrrrrrrr%rbrUrrrs@rCr-r-s      HHH&&&&&&&&&4444 &&&&&&&&&%%%(((000...&&&&&& ... .... ....,,,....&&&&..........rDr-cV|D]%}t|tsJd|d&dS)NzTerm rnT)r:r)termsrs rCr|r|/ sC LL!T""KKK$KKKKK 4rDceZdZdZddededefdZdZd e e e e e fe e e e e ffd dfd Z d ee e e e e ffd ZdZdZdS)r.a) 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 Fr batch_size batch_addnc|r|dkrtd||_|f|_||_||_|dS)Nz$batch_size must be a positive number)rr_BatchAddGraph__graph_tuple_BatchAddGraph__batch_size_BatchAddGraph__batch_addnreset)rArrkrls rCr8zBatchAddGraph.__init__H sT EZ!^^CDD D #X&& rDc"g|_d|_|S)zQ Manually clear the buffered triples and reset the count to zero r)batchcountrGs rCrrzBatchAddGraph.resetQ s   rDrrcLt|j|jkr&|j|jg|_|xjdz c_t|dkr#|j||jzn|j||S)zV Add a triple to the buffer :param triple: The triple to add rr)rrtrprrrurro)rArs rCrszBatchAddGraph.addY s tz??d/ / / JOODJ ' ' 'DJ a ~  ! # # J  nt/AA B B B B J  n - - - rDrxc~|jr|D]}||n|j||SrF)rqrsrr)rArxqs rCrzBatchAddGraph.addNl sM   #     JOOE " " " rDc.||SrF)rrrGs rC __enter__zBatchAddGraph.__enter__t s  rDcX|d!|j|jdSdSNr)rrrt)rAexcs rC__exit__zBatchAddGraph.__exit__x s. q6> JOODJ ' ' ' ' ' >rDN)rjF)rVrrrr&r.rr8rrrr rrrsrrrzr~rYrDrCr.r.5 s$eeD$$45uT4s=R7SST &(5tT3)>#?@(((((rDr.c6ddl}|dSr|)doctesttestmod)rs rCtestr} s!NNN OOrD__main__)Otypingrrrrrrr r r r loggingwarningsr rrdflib.namespacerrr_rrrrrrrrrr rdflib.pathsr rdflib.storerrdflib.serializerr rdflib.parserrrrrdflib.resourcerrdflib.collectionr! rdflib.utilrdflib.exceptionsr"rDrFrBr?ior# urllib.parser$urllib.requestr% getLoggerrVlogger ContextNoderr__all__r&r'rr+r(term _ORDERINGrr)rr*r,r-r|r.rrYrDrCrs                         ++++++++777777777777;;;;;;;;;;;;;;((((((55555555------$$$$$$(((((()))))) !!!!!!''''''  8 $ $E6M" D&$(==> t n   zzzzzDzzzz'O?O?O?O?O?uO?O?O?d"6"899X4X4X4X4X4X4X4X4v/:/:/:/:/:%/:/:/:l&( k"/////&///d     I   XXXXXIXXXM.M.M.M.M.-M.M.M.` E(E(E(E(E(FE(E(E(P  zDFFFFFrD