4YshoEddlmZmZmZmZmZmZmZmZm 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 jpe9Z:eeefZ;e eeeee;fZGddeZ?Gdde?Z@edZAGdde@ZBGdde?ZCdejjeC<GddeFZGGd d!eHZIGd"d#eHZJGd$d%e@ZKd&ZLGd'd(eFZMd)ZNe9d*k(reNyy)+) 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 dcdeeefdeeeefdee deeffd Z dZ e e Z d Ze eZd Zd Ze eed ZdZdZdZdZdZdZdddZdddZdeeeeffdZdeeeeeeffdZdZ deeeede!efeeffdZ"dZ#dZ$dZ%dZ&d Z'd!Z(d"Z)d#Z*d$Z+d%Z,d&Z-d'Z.d(Z/d)Z0d*Z1d+Z2d,Z3e0Z4e1Z5d-Z6ded.eefd/Z7ded.eefd0Z8ded.eefd1Z9dfd2Z:dfd3Z;dfd4Zj~ddd6fd7Z?dgd8Z@ddeAjjeAjjffd9ZEdgd:ZFd;ZGdfd<ZHdfd=ZIdfd>ZJd?ZKd@ZLdhdAZMdidBZNdCZOdjdDZPeQdEddFedeedGed.eRf dHZSeQ dkdEddFedeedGed.eRf dIZSeQ dldEddFedeedGdd.ef dJZSeQ dkdEeeeTjeVeRfdFedeedGeed.df dKZSeQ dldEeeeeTjeVeRfdFedeedGeed.eeRedff dLZS dmdEeeeeTjeVeRfdFedeedGeedMed.eeRedff dNZSdndOZW dodFeedPeeeeReXffdQZYdpdRZZ dqdSeee[jfdTeee]e[jfdUe_d.e[jfdVZ[ drdWZ`dXZadYZbdZZcd[Zdd\Zed]Zfd^Zgd_Zhdsd`ZidedaZjdbZkxZlS)tr&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/ Nstore identifiernamespace_managerbasectt| ||_||xs t |_t |j tst|j |_|t |ts'tj|tx|_ }n||_ ||_ d|_d|_d|_yNF)superr&__init__r3r_Graph__identifier isinstancerrrrget _Graph__store_Graph__namespace_manager context_aware formula_aware default_union)selfr0r1r2r3 __class__s l/var/www/sten-cake5-migrate2.hellocrow.space/lexinfo-master/env/lib/python3.12/site-packages/rdflib/graph.pyr7zGraph.__init__Gs eT#%  &1%'$++T2 &t'8'8 9D  %'#;6::eU#;#= =DL5 DL#4 """c|jSN)r;r@s rB __get_storezGraph.__get_store_s ||rCc|jSrE)r8rFs rB__get_identifierzGraph.__get_identifierds   rCcR|jt||_|jSrE)r<rrFs rB_get_namespace_managerzGraph._get_namespace_manageris'  # # +'7'=D $'''rCc||_yrE)r<)r@nms rB_set_namespace_managerzGraph._set_namespace_managerns #% rCzthis graph's namespace-manager)docc:d|jdt|dS)Nz)r1typerFs rB__repr__zGraph.__repr__ws/3T KKrCct|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']].)r9r1rn3r0rA__name__rFs rB__str__z Graph.__str__zsc doov .##%tzz';';'D'DF F W $$--. .rCc|SrErFs rBtoPythonzGraph.toPython rCc<|jj||S)zzGraph.addN..sO 1a!U# /Aq!$ 1aL A A )r;addNr@rws` rBrz Graph.addNs+  #   rCc@|jj|||S)zRemove a triple from the graph If the triple does not provide a context attribute, removes the triple from all contexts. context)r;remover@ris rBrz Graph.removes FD1 rCc#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)r9revalr;triples)r@rirtrurv_s_ocgs rBrz Graph.tripless1a a &&q!, B!Ri "&!5!5q!Qi!5!N  Aq2Ag  sA.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.)r9slicestartstopsteprsubject_predicatessubject_objectspredicate_objectssubjects predicatesobjectsrr TypeError)r@itemrtrurvs rB __getitem__zGraph.__getitem__sT dE "jj$))TYY!qAyQY19||Q1I..qy..q11qy++A..qy--a00}}Q**q!,,||Aq))1ayD(( tTl +))$/ /i rCc:|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)r;__len__rFs rBrz Graph.__len__s ||##D#11rCc$|jdS)z&Iterates over all triples in the storeNNNrrFs rB__iter__zGraph.__iter__%s||.//rCc2|j|D]}yy)z$Support for 'triple in graph' syntaxTFrrs rB __contains__zGraph.__contains__)s ll6* F rCc,t|jSrE)hashr1rFs rB__hash__zGraph.__hash__/sDOO$$rCc|yt|tr3|j|jkD|j|jkz Sy)Nr9r&r1r@others rB__cmp__z Graph.__cmp__2sG = u %OOe&6&66%"2"22 rCcXt|txr|j|jk(SrErrs rB__eq__z Graph.__eq__?s#%'ODOOu?O?O,OOrCcd|duxs+t|txr|j|jkSrErrs rB__lt__z Graph.__lt__Bs1  ue $ K5;K;K)K rCc||kxs||k(SrErXrs rB__le__z Graph.__le__Ge|,tu},rCcdt|txr|j|jkDxs|duSrErrs rB__gt__z Graph.__gt__Js25%(OT__u?O?O-O   rCc||kDxs||k(SrErXrs rB__ge__z Graph.__ge__OrrCc<jfd|DS)zKAdd all triples in Graph other to Graph. BNode IDs are not changed.c32K|]\}}}|||fywrErX)r}rtrurvr@s rBrz!Graph.__iadd__..Us7gaA1aD/7s)rrs` rB__iadd__zGraph.__iadd__Rs 777 rCc6|D]}|j||S)zRSubtract all triples in Graph other from Graph. BNode IDs are not changed.)r)r@rris rB__isub__zGraph.__isub__Xs$ F KK   rCcf t|}tt |j t |j zD]\}}|j |||D]}|j||D]}|j||S#t$r t}YwxYw)z6Set-theoretic union BNode IDs are not changed.)rQrr&setlist namespacesbindrr)r@rretvalprefixurixys rB__add__z Graph.__add___s T$Z\F!doo&7!84@P@P@R;S!ST %MVS KK $ % A JJqM  A JJqM   WF sBB0/B0c t|}|D]}||vs|j||S#t$r t}Y4wxYw)z>Set-theoretic intersection. BNode IDs are not changed.rQrr&rrr@rrrs rB__mul__z Graph.__mul__nsV T$Z\F ADy 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, *, *))rrr)r@risubject predicateobject_s rBrz Graph.setsm )/%)W   L K L   ! L K L ! Wi./ '9g./ rCreturnc#NK|jd||fD] \}}}| yw)z;A generator of subjects with the given predicate and objectNr)r@robjectrtrurvs rBrzGraph.subjectss0||T9f$=> GAq!G #%c#NK|j|d|fD] \}}}| yw)z;A generator of predicates with the given subject and objectNr)r@rrrtrurvs rBrzGraph.predicatess0||WdF$;< GAq!G rc#NK|j||dfD] \}}}| yw)z;A generator of objects with the given subject and predicateNr)r@rrrtrurvs rBrz Graph.objectss0||Wi$>? GAq!G rc#RK|jdd|fD] \}}}||fyw)z?A generator of (subject, predicate) tuples for the given objectNr)r@rrtrurvs rBrzGraph.subject_predicatess4||T4$89 GAq!Q$J %'c#RK|jd|dfD] \}}}||fyw)z?A generator of (subject, object) tuples for the given predicateNr)r@rrtrurvs rBrzGraph.subject_objectss4||T9d$;< GAq!Q$J rc#RK|j|ddfD] \}}}||fyw)z?A generator of (predicate, object) tuples for the given subjectNr)r@rrtrurvs rBrzGraph.predicate_objectss4||WdD$9: GAq!Q$J rc#~K|\}}}|jj|||f|D]\\}}}} |||fyw)Nr)r0triples_choices) r@rirrrrrtrurvrs rBrzGraph.triples_choicessX&,#G!ZZ77 i )48  MIQ1rQ'M s;=Tc |}||||||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) ) rrrnextr0rrrUniquenessError StopIteration)r@rrrdefaultanyrvaluesmsgrrtrurvcontextss rBvaluez Graph.valuesH"_!2FN!fn >\\'95F ?]]9f5F  __Wf5F &\Fe|L#Iv7 #jj00'9f1MtTG/6+ Aq8 N  %44S99 % ) F* - s% C#A4C C C # C21C2cttd||S|j|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.Trr)r DeprecationWarningrrRDFSlabelr@rrs rBrz Graph.labelsD R  ?Nzz'9>>#7#7dzSSrCc ttd|g}dk(rd}n fd}nd}|D]I}tt||j ||}t |dk(r7|Dcgc]}||fc}cS|Scc}w)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.c|jduSrElanguagel_s rB langfilterz(Graph.preferredLabel..langfilterMs;;$..rCc"|jk(SrEr)rlangs rBrz(Graph.preferredLabel..langfilterRs;;$..rCcy)NTrXrs rBrz(Graph.preferredLabel..langfilterWsrCr)r rrfilterrlen) r@rrrlabelPropertiesr labelProplabelsrs ` rBpreferredLabelzGraph.preferredLabelsd [  ?G  rz/ /  ) :I&T\\'9-MNOF6{a289BB99  : :s+ A>cttd||S|j|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.Tr)r rrrrcommentrs rBrz Graph.commentbsE T  ?Nzz'9>>#9#97PTzUUrCc#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)rrrfirstrest ValueErrorrr)r@rchainrs rBitemsz Graph.itemspsl 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)r@funcargseenrtrt_2s rBr zGraph.transitiveClosuresc^ <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)r@rrrememberrrvs rBrzGraph.transitive_objectssj  H h   ll7I6 F,,VYI   AA 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)r@rrrrrts rBrzGraph.transitive_subjectssj  H X   }}Y7 G--i(K   rcttd|tjtjf|vr t ||Sy)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 rrrQr))r@rs rBseqz Graph.seqs@ P  SXXsww '4 /tW% %rCc8|jj|SrE)r2qnamer@rs rBrz Graph.qnames%%++C00rCc:|jj||SrE)r2 compute_qnamer@rgenerates rBr zGraph.compute_qnames%%33CBBrCc@|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)r2r)r@rrr$r%s rBrz Graph.binds+%%** I'+  rCc#\K|jjD] \}}||f yw)z/Generator over all the prefix, namespace tuplesN)r2r)r@rrs rBrzGraph.namespacess4!%!7!7!B!B!D $ FI)# # $s*,c:|jj||S)z5Turn uri into an absolute URI if it's not one already)r2 absolutizer@rdefrags rBr(zGraph.absolutizes%%00f==rC destinationformatencodingc yrErXr@r+r,r3r-argss rB serializezGraph.serializes rCc yrErXr/s rBr1zGraph.serialize s rCc yrErXr/s rBr1zGraph.serialize rCc yrErXr/s rBr1zGraph.serialize&r4rCc yrErXr/s rBr1zGraph.serialize2r4rCr0c | |j}tj|t|}|gt }|5|j |f|dd||j jdS|j |f||d||j St|dr/ttt|}|j |f||d||St|tjr t|}ntt|}t!|\} } } } } }| dk7rt#d|dt%j&\}}t)j*|d}|j |f||d||j-| dk(r t/| n|}tt0d rt1j2|||St1j4||t)j6||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. utf-8)r3r-writerz destination z is not a local file referencewbfilemove)r3rr:rr#r1getvaluedecodehasattrr rbytesr9pathlibPurePathstrr$r tempfilemkstemposfdopenrhr%shutilr<copyr)r@r+r,r3r-r0 serializerstreamlocationschemenetlocpathparams_queryfragmentfdnamedests rBr1zGraph.serialize=s. <99D3VZZ 3D9  YF$ $$VQ$QDQ(//88$ $$VR$RTR(( ; ("U)[1F J  NdX N N* '+w'7'78{+[1=Eh=O :FFD&&(| ";-/MN '')HBYYr4(F J  NdX N N LLN)/6)9<%xDvv& D$'  D$' $ rCcbt|jd||j||dy)N)r,r-T)r;flush)printr1r>)r@r,r-outs rBrXz Graph.printzs- NN4N B I I( S rCdatac xt||||||}| |j}d}|t|drnt|jddrWt |jj tr3tjj|jj }|d}d}tj|t} | j||fi| |j"r|j%|S#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. :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 sourcepublicIDrLr;rZr,NFr;rTturtleTzCould 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?getattrr;r9rTrCrdflibutil guess_formatrr:rparse SyntaxErrorr" auto_closerh) r@r]r^r,rLr;rZr0could_not_guess_formatparserses rBrez Graph.parses3b%   >((F!& >'FKK6v{{//511&++2B2BC~!)-&+FF+-  FLL . .     %!S     !s$C77 DDDDD9cPttd|j|||S)Nzagraph.load() is deprecated, it will be removed in rdflib 6.0.0. Please use graph.parse() instead.)r rre)r@r]r^r,s rBloadz Graph.loads, 4  zz&(F33rC processorresultuse_store_providedc f|xsi}|xst|j}t|jdr?|r= |jj||||j xrdxs |j fi|St|tjs2tjtt|tj}t|tjs*tj|tj|}||j|||fi|S#t$rYwxYw)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?r0rr?r1NotImplementedErrorr9Resultrr:r rC Processor)r@ query_objectrmrninitNs initBindingsrokwargss rBrz Graph.querys0$)r 24 12 4::w ',> 'tzz''  &&6;I$//   &%,,/ZZS& 15<<@F)U__5> 9eoo>tDIoioolL&SFSTT'  s;D$$ D0/D0c |xsi}|xst|j}t|jdr?|r= |jj||||j xrdxs |j fi|St|tjs*tj|tj|}|j|||fi|S#t$rYdwxYw)z.Update this graph with the given update query.updaterq) rrrr?r0r{r?r1rsr9rUpdateProcessorrr:)r@ update_objectrmrwrxrorys rBr{z Graph.update0s$)r 24 12 4::x (-? (tzz((! &&6;I$//   )U%:%:;D 9e.C.CDTJIy |VNvNN '  s;C CCc<d|jjzS)%Return an n3 identifier for the Graphz[%s]r1rTrFs rBrTzGraph.n3N**,,,rCc>t|j|jffSrE)r&r0r1rFs rB __reduce__zGraph.__reduce__Rs"     rCc 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)rr9r)r@rrtrurvs rB isomorphiczGraph.isomorphic[s t9E " !GAq!a' 1e0D1ayE)  ! !GAq!a' 1e0D1ayD(  ! rCct|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)rT) r all_nodesrandom randrangerpopappendrr)r@r discoveredvisitingrnew_xs rB connectedzGraph.connectedps)*  f..s9~>?@ A "!!!$a0 + *uH/DOOE* +a0 + *uH/DOOE* + y>S_ ,rCcvt|j}|j|j|SrE)rrr{r)r@ress rBrzGraph.all_nodess)$,,.! 4==?# rCct||S)aCreate a new ``Collection`` instance. Parameters: - ``identifier``: a URIRef or BNode instance. Example:: >>> graph = Graph() >>> uri = URIRef("http://example.org/resource") >>> collection = graph.collection(uri) >>> assert isinstance(collection, Collection) >>> assert collection.uri is uri >>> assert collection.graph is graph >>> collection += [ Literal(1), Literal(2) ] r r@r1s rB collectionzGraph.collections$$ ++rCcPt|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 )r9rrrrs rBresourcezGraph.resources%"*d+ +Jj))rCc^|jdD]}|j||y)Nr)rrr)r@targetrts rB_process_skolem_tupleszGraph._process_skolem_tupless+01 A JJtAw  rCcfdfd}| tn|}|j|||Sttr|j|fd|S)Ncz|\}}}||k(r|j}||k(r|j}|||fSN) authoritybasepath) skolemize)bnoderrtrurvrrs rB do_skolemizez%Graph.skolemize..do_skolemizesKIQ1EzKK)hKGEzKK)hKGa7NrCc|\}}}t|tr|j}t|tr|j}|||fSr)r9rr)rrtrurvrrs rB do_skolemize2z&Graph.skolemize..do_skolemize2sQIQ1!U#KK)hKG!U#KK)hKGa7NrCc|SrErX)rrrs rBz!Graph.skolemize..s,ua:PrC)r&rr9r)r@ new_graphrrrrrrs ``` @rBrzGraph.skolemizes[  &-9 =  ' ' > u %  ' '0P Q rCcdd}| tn|}|j|||Sttr|j|fd|S)Ncl|\}}}||k(r|j}||k(r|j}|||fSrE) de_skolemize)urirefrrtrurvs rBdo_de_skolemizez+Graph.de_skolemize..do_de_skolemizes>IQ1F{NN$F{NN$a7NrCc|\}}}t|tr|j}t|tr|j}|||fSrE)r9rr)rrtrurvs rBdo_de_skolemize2z,Graph.de_skolemize..do_de_skolemize2sDIQ1!U#NN$!U#NN$a7NrCc|SrErX)rrrs rBrz$Graph.de_skolemize..s/&RS:TrC)r&rr9r)r@rrrrrs ` @rBrzGraph.de_skolemizes\  &-9 >  ' '0@ A  &  ' '0T U rCc>tfd|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 cfj|ddfD]=\}}} j|||ft|tk(s.|ddf vs6|?jdtj |fD]7\}}}j|ddfD]\}}} j|||f9yrE)rrrrQrrr) rrtrurvs2p2o2 add_to_cbdr@subgraphs rBrzGraph.cbd..add_to_cbds<<dD(9: "1a aAY'7e#QdOx,GqM  " <<s{{C(@A /1a"&,,4"?/JBBLL"b"./ /rC)r&)r@rrrs` @@rBcbdz Graph.cbds :7 /$ 8rC)rNNNFNNrE)rT)TFr)...)....)Nr_NN)r_r8NNNNNNN)Nxml)sparqlrNNT)rNNTNNNN)mrU __module__ __qualname____doc__rrrCrrrr7_Graph__get_storepropertyr0_Graph__get_identifierr1rKrNr2rRrVrYr\r`rbrdrhr rrrrrrrrrrrrrrrrrrrrrrrrr__or____and__rrrrrrrrrrrrSKOS prefLabelrrrr r rrrrr rrr(r r@r1rArBrrX bytearrayrerlrrurrtboolr{rTrrrrrrrrrr __classcell__rAs@rBr&r&4s($-158<" #UCZ #U49-.#$$45 # sm #0 [ !E!*+J( &! , L.   8Y%dD 01 (5tT3)>#?@ HTNE$d2B,CXd^ST FP20 % P - -    / FG"x~ x~ x~    ciidPT9v T""119>>3G3GH Qf V 7r  1C  $ >   ), 4uwEW rCcLd}||jjjzS)NzK[a rdflib:ConjunctiveGraph;rdflib:storage [a rdflib:Store;rdfs:label '%s']]r0rArUr@patterns rBrVzConjunctiveGraph.__str__Os) 0 --6666rCtriple_or_quadrcyrErXr@rrs rB_spoczConjunctiveGraph._spocVs rCcyrErXrs rBrzConjunctiveGraph._spoc`s rCc|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)r@rrr~rtrurvs rBrzConjunctiveGraph._spochs  !$gd&:&:P P4P P ~ ! #(/$$TA&IQ1  A %)LQ1a AA!QzrCch|j|\}}}}|j|||f|D]}yy)z)Support for 'triple/quad in graph' syntaxrTF)rr)r@rrtrurvr~rs rBrzConjunctiveGraph.__contains__}s@ZZ/ 1aq!Qi3 A rCc|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 TrF)rrq)rr{r0rrr@rrtrurvr~s rBrrzConjunctiveGraph.addsKZZZ= 1aAq! 1ay!E: rCr~cyrErXr@r~s rBrzConjunctiveGraph._graph rCcyrErXrs rBrzConjunctiveGraph._graphrrCcN|yt|ts|j|S|SrE)r9r& get_contextrs rBrzConjunctiveGraph._graphs* 9!U###A& &HrCrwcPjjfd|DS)z&Add a sequence of triples with contextc3nK|],\}}}}t|||s|||j|f.ywrE)r{rr|s rBrz(ConjunctiveGraph.addN..s< *4!Q1QPQSTAUQ1dkk!n % s55r0rrs` rBrzConjunctiveGraph.addNs)  8=   rCcr|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)rr0rrs rBrzConjunctiveGraph.removes<ZZ/ 1a 1a)Q/ rCc#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) rrr?rr9rrr0r)r@rrrtrurvr~rs rBrzConjunctiveGraph.triplessZZ/ 1a++gl+   $..... a w1- 1Ag  "&!3!3Q1Iw!3!O  Aq2Ag  sCCc#K|j|\}}}}|jj|||f|D]\\}}}}|D] }||||f yw)z:Iterate over all the quads in the entire conjunctive graphrN)rr0r)r@rrtrurvr~rctxs rBrwzConjunctiveGraph.quadssnZZ/ 1a!ZZ//Aq 1/E #MIQ1r #Asl" # #sAAc#K|\}}}||js|j}n|j|}|jj |||f|D]\\}}}} |||fyw)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. r\r0r1r)r^r,) r getPublicIdr9rrr&r0rre) r@r]r^r,rLr;rZr0g_idrs rBrezConjunctiveGraph.parses,%  $H<(:(:(<$%$t|j|jffSrE)r'r0r1rFs rBrzConjunctiveGraph.__reduce__?s$**doo!>>>rC)rNNr)r~NrNrE)FNr)"rUrrrrrrCrrr7rVr r rrr&rrrrrrrrrrwrrrrrrrerrrs@rBr'r'1s $-15,0  UCZ  U49-. %SM  7    $dHSM1 2E$d:J4K K    tT4%0 1       tT4%0 1     %dD(3-78%dD@P:QQ R    x~x~x~xN O * %dD$ .M(NPUVZ\`bfVfPg(g"h m  eT3./ E    udC'7!89huo(5tT3)>#?@ :# $ 0""  U49-.    sm    7,  'R?rCr'zurn:x-rdflib:defaultceZdZdZdfd ZdZdZdZdZddZ dd Z d Z d Z dfd Z e Zfd ZdeeddffdZxZS)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 Nctt| |d|jjs t dt |jt||_||_ y)Nrz.DataSet must be backed by a graph-aware store!r) r6r+r7r0 graph_aware Exceptionr&DATASET_DEFAULT_GRAPH_IDrr?)r@r0r?rrAs rBr7zDataset.__init__sT gt%Ed%Czz%%LM M$**/#  +rCcLd}||jjjzS)NzB[a rdflib:Dataset;rdflib:storage [a rdflib:Store;rdfs:label '%s']]rrs rBrVzDataset.__str__s' S --6666rCcHt||j|jffSrE)rQr0r?rFs rBrzDataset.__reduce__s T TZZ););<==rCc^|j|j|j|jfSrEr0r1rr?rFs rB __getstate__zDataset.__getstate__s%zz4??D,@,@$BTBTTTrCc:|\|_|_|_|_yrEr )r@states rB __setstate__zDataset.__setstate__sPUM DOT%94;MrCc|5ddlm}|jdd|zdtj }|j |}||_|jj||S)Nr)rdflib_skolem_genidgenidzhttp://rdflib.netF)r$) rdflib.termrrrrrr3r0 add_graph)r@r1r3rgs rBgraphz Dataset.graphsh   7 II,/BBU  **,J KK # QrCc `tj|||||||fi|}|j||SrE)r'rer) r@r]r^r,rLr;rZr0r~s rBrez Dataset.parses=  " " &(FHdD DH  1 rCc$|j|S)zalias of graph for consistency)rr@rs rBrzDataset.add_graphszz!}rCct|ts|j|}|jj ||||j k(r%|jj |j |SrE)r9r&rr0 remove_graphrrrs rBrzDataset.remove_graphs_!U#  #A " 9T111 JJ !5!5 6 rCc#Kd}tt| |D]}||jtk(z}||s|j tyywr5)r6r+rr1rr)r@rirr~rAs rBrzDataset.contexts sZw.v6 A q||'?? ?GG **56 6sAAc#Ktt| |D];\}}}}|j|jk(r |||df*||||jf=ywrE)r6r+rwr1r)r@quadrtrurvr~rAs rBrwz Dataset.quadss]4T: ,JAq!Q||t333Atm#Aq||++  ,sAArc$|jdS)z$Iterates over all quads in the storer)rwrFs rBrzDataset.__iter__szz233rC)rFNrrrE)rUrrrr7rVrr rrrerrrgraphsrwr DatasetQuadrrrs@rBr+r+FsxxGt +7 >UV "    7F,4)Kt$;<4rCr+cjeZdZdZfdZdeeeeffdZdeeeeefddfdZ 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. c.tt| ||yrE)r6r(r7)r@r0r1rAs rBr7zQuotedGraph.__init__)s k4)%.9sO 1a![) /Aq!$ 1aL rrrs` rBrzQuotedGraph.addN6s)  #   rCc<d|jjzS)rz{%s}rrFs rBrTzQuotedGraph.n3BrrCc|jj}|jjj}d}|||fzS)NzK{this rdflib.identifier %s;rdflib:storage [a rdflib:Store;rdfs:label '%s']})r1rTr0rArU)r@r1rrs rBrVzQuotedGraph.__str__FsE__'')  $$-- 0 *e,,,rCc>t|j|jffSrE)r(r0r1rFs rBrzQuotedGraph.__reduce__OsTZZ999rC)rUrrrr7r rrrrrrTrVrrrs@rBr(r(!sU=%dD 01 %dD# 56 = --:rCr( c.eZdZdZdZdZdZdZdZy)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. c.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! _rN) r_listrrCrr startswithintr%rsort)r@rrr.LI_INDEXrurvis rBr7z Seq.__init__cs~"V# #c(S.)--g6 %FQ||H% (B/0 aV$ %  rCc|SrErXrFs rBrYz Seq.toPythonzrZrCc#<K|jD] \}}| yw)z#Generator over the items in the SeqN)r.)r@r-rs rBrz Seq.__iter__}s"zz GAtJ sc,t|jS)zLength of the Seq)rr.rFs rBrz Seq.__len__s4::rCcB|jj|\}}|S)z Item given by index from the Seq)r.r)r@indexrs rBrzSeq.__getitem__sjj,,U3 t rCN) rUrrrr7rYrrrrXrCrBr)r)Zs . rCr)ceZdZdZdZy)r*cyrErXrFs rBr7zModificationException.__init__ rCc y)NzZModifications and transactional operations not allowed on ReadOnlyGraphAggregate instancesrXrFs rBrVzModificationException.__str__s  / rCNrUrrr7rVrXrCrBr*r*s   rCr*ceZdZdZdZy)r,cyrErXrFs rBr7z&UnSupportedAggregateOperation.__init__r;rCcy)NzCThis operation is not supported by ReadOnlyGraphAggregate instancesrXrFs rBrVz%UnSupportedAggregateOperation.__str__sWrCNr=rXrCrBr,r,s  XrCr,ceZdZdZdfd ZdZdZdZdZddZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZddZdZd dZd dZdZd!dZd"dZdZdZxZS)#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. c|0tt| |tj||d|_t |t r#|r!|Dcgc]}t |ts|c}sJd||_ycc}w)Nz*graphs argument must be a list of Graphs!!)r6r-r7r&*_ReadOnlyGraphAggregate__namespace_managerr9rr )r@r r0rrAs rBr7zReadOnlyGraphAggregate.__init__sw   ($ 8 ? NN4 ''+D $ vt $";qjE&:; 8 8  8 < )rr rFs rBrRzReadOnlyGraphAggregate.__repr__s4s4;;7GGGrCctrEr*r]s rBr\zReadOnlyGraphAggregate.destroy #%%rCctrErFrFs rBr`zReadOnlyGraphAggregate.commitrGrCctrErFrFs rBrbzReadOnlyGraphAggregate.rollbackrGrCcL|jD]}|j|||yrE)r rd)r@r^rers rBrdzReadOnlyGraphAggregate.opens%[[ 4E JJt]F 3 4rCcF|jD]}|jyrE)r rh)r@rs rBrhzReadOnlyGraphAggregate.closes[[ E KKM rCctrErFrs rBrrzReadOnlyGraphAggregate.addrGrCctrErFrs rBrzReadOnlyGraphAggregate.addNrGrCctrErFrs rBrzReadOnlyGraphAggregate.removerGrCc#K|\}}}|jD]Y}t|tr#|j|||D] \}}|||f6|j |||fD] \}}}|||f[ywrE)r r9rrr r@rirtrurvrrrrs rBrzReadOnlyGraphAggregate.tripless1a[[ %E!T"FF4A."DAqQ'M"#(--Aq ":%JBBb"*$%  %sA0A2cd}t|dk(r|d}|jD]'}||j|jk(s|dd|vs'yy)NrrTF)rr r1)r@rrrs rBrz#ReadOnlyGraphAggregate.__contains__s` ~ ! #$Q'G[[ E%"2"2g6H6H"H!"1%. rCc#K|\}}}|jD]'}|j|||fD]\}}}||||f)yw)z8Iterate over all the quads in the entire aggregate graphN)r rrPs rBrwzReadOnlyGraphAggregate.quadssW1a[[ (E#mmQ1I6 ( B"b%'' ( (s>Ac:td|jDS)Nc32K|]}t|ywrE)r)r}rs rBrz1ReadOnlyGraphAggregate.__len__..s/a3q6/s)sumr rFs rBrzReadOnlyGraphAggregate.__len__s/4;;///rCctrEr,rFs rBrzReadOnlyGraphAggregate.__hash__ +--rCc|yt|tryt|tr3|j|jkD|j|jkz Sy)Nr)r9r&r-r rs rBrzReadOnlyGraphAggregate.__cmp__sJ = u % 5 6KK%,,.4;;3MN NrCctrErFrs rBrzReadOnlyGraphAggregate.__iadd__rGrCctrErFrs rBrzReadOnlyGraphAggregate.__isub__ rGrCc#K|\}}}|jD](}|j|||f}|D] \}} } || | f*ywrE)r r) r@rirrrrrchoicesrtrurvs rBrz&ReadOnlyGraphAggregate.triples_choices s\&,#G[[ E++Wi,IJG$  AqAg   rc|t|dr'|jr|jj|StNr2)r?r2rr,rs rBrzReadOnlyGraphAggregate.qname s5 4, -$2H2H))//4 4+--rCc~t|dr(|jr|jj||Str_)r?r2r r,r!s rBr z$ReadOnlyGraphAggregate.compute_qname s7 4, -$2H2H))77XF F+--rCctrErW)r@rrr$s rBrzReadOnlyGraphAggregate.bind rXrCc#Kt|dr)|jjD] \}}||f y|jD] }|jD] \}}||f "ywr_)r?r2rr )r@rrrs rBrz!ReadOnlyGraphAggregate.namespaces s| 4, -%)%;%;%F%F%H (! i'' ( ,).)9)9);,%FI )++, ,sA&A(ctrErWr)s rBr(z!ReadOnlyGraphAggregate.absolutize" rXrCc trErF)r@r]r^r,r0s rBrezReadOnlyGraphAggregate.parse% rGrCctrErWrFs rBrTzReadOnlyGraphAggregate.n3( rXrCctrErWrFs rBrz!ReadOnlyGraphAggregate.__reduce__+ rXrCrrrErrr) rUrrrr7rRr\r`rbrdrhrrrrrrrwrrrrrrrr rrr(rerTrrrs@rBr-r-s H&&&4 &&&%(0.&& . . .,.&..rCr-cH|D]}t|trJd|dy)NzTerm rmT)r9r)termsrs rBr{r{/ s. L!T"K$KK"L rCceZdZdZddededefdZdZde e e e e fe e e e e ffddfd Z d ee e e e e ffd Zd Zd Zy)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 r batch_size batch_addnc|r|dkr td||_|f|_||_||_|j y)Nz$batch_size must be a positive number)r r_BatchAddGraph__graph_tuple_BatchAddGraph__batch_size_BatchAddGraph__batch_addnreset)r@rrjrks rBr7zBatchAddGraph.__init__H sAZ!^CD D #X&& rCc"g|_d|_|S)zQ Manually clear the buffered triples and reset the count to zero r)batchcountrFs rBrqzBatchAddGraph.resetQ s   rCrrcrt|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 rr)rrsrorrrtrrn)r@rs rBrrzBatchAddGraph.addY s tzz?d// / JJOODJJ 'DJ a ~ ! # JJ  nt/A/AA B  JJ  n - rCrwc|jr|D]}|j||S|jj||SrE)rprrrr)r@rwqs rBrzBatchAddGraph.addNl sC        JJOOE " rCc&|j|SrE)rqrFs rB __enter__zBatchAddGraph.__enter__t s  rCcZ|d&|jj|jyyNr)rrrs)r@excs rB__exit__zBatchAddGraph.__exit__x s$ q6> JJOODJJ ' rCN)iF)rUrrrr&r0rr7rqrr rrrrrrryr}rXrCrBr.r.5 s$eeD$$45uT4s=R7SST &(5tT3)>#?@(rCr.c,ddl}|jyr{)doctesttestmod)rs rBtestr} s OOrC__main__)Otypingrrrrrrr r r r loggingwarningsr rrdflib.namespacerrrbrrrrrrrrrr rdflib.pathsr rdflib.storerrdflib.serializerr rdflib.parserrrrrdflib.resourcerrdflib.collectionr! rdflib.utilrdflib.exceptionsr"rFrHrDrAior# urllib.parser$urllib.requestr% getLoggerrUlogger ContextNoder!r__all__r&r'rr+r(term _ORDERINGrr)rr*r,r-r{r.rrXrCrBrs}    +77;;(5-$() !'wy   8 $E6M" D&$(==> t n zDzz'O?uO?d""89X4X4v/:%/:l&( k"/&/d I XIXM.-M.` E(FE(P  zFrC