01ie%SrSSKJr SSKrSSKrSSKJr /SQrSSKrSSK r SSK r SSK r SSK JrJr SSKJrJr SSKJr SS KJrJrJrJr SS KJr SS KJrJr SS KJr SS KJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r* SSK+J,r,J-r-J.r. SSK/J0r0 SSK1r1SSK2r1SSK3J4r4 SSK5J6r6J7r7J8r8J9r9J:r:J;r; \ (aSSKJ?r?J@r@JArAJBrBJCrC SrDSSKErESrDSrG\R"\I5rJSrKSrL0rMS\NS'SrOSSjrP\"S5rQSSjrRSS jrS"S!S"\R5rU"S#S$\U\V5rW"S%S&\W5rX"S'S(\X5rY"S)S*\Y5rZ"S+S,\Z5r[SS-jr\"S.S/\X5r]"S0S1\W5r^SS2jr_SS3jr`SS4jraSS5jrbSS6jrcSS7jrdSS8jreSS9jrfSS:jrgSS;jrhSS<jriSS=jrjSS>jrkSS?jrlSS@jrmSSAjrnSSBjroSSCjrpSSDjrqSErrSFrs\Y"\sSG-5rt\Y"\sSH-5ru\Y"\rSI-5rv\Y"\rSJ-5rw\Y"\rSK-5rx\Y"\rSL-5ry\Y"\rSM-5rz\Y"\rSN-5r{\Y"\rSO-5r|\Y"\rSP-5r}\Y"\rSQ-5r~\Y"\rSR-5r\Y"\rSS-5r\Y"\rST-5r\Y"\rSU-5r\Y"\rSV-5r\Y"SW5r\Y"\rSX-5r\Y"\rSY-5r\Y"\rSZ-5r\Y"\rS[-5r\|\{\z\Y"\rSL-5\Y"\rS\-5\Y"\rS]-5\Y"\rS^-5\Y"\rS_-5\Y"\rS`-5\Y"\rSa-5\Y"\rSb-5\Y"\rSc-5\Y"\rSd-5\Y"\rSe-5\Y"\rSf-5\Y"\rSg-54rSh\NSi'\|\}\z\{\4rSh\NSj'\Y"\rSL-5\z\{4rSh\NSk'\~\\4rSh\NSl'\\4rSh\NSm'\\-rSh\NSn'\So\Sp\ GRGR GR"Sq0rSr\NSs'\v\t\u\Y"\rSJ-5\Y"\rSK-54rSh\NSt'\)"Su\VSv9rSSwjrSSxjr\VSy4\S\z44\Sz\}44\S\|44\4S\|44\S{\{44\S|\~44\S}\44\S~\44\6S\44\S\44\ GRGR GR"\b\t44\S\44/ rS\NS'\Eb7\GR7\ GRGR GR8\a\u445 \"\5r\\4S4\\4S4\V\4\4\\4\4\V\4\4\\4\4/rS\NS'\"\5r0SS_\Y"\rSS-5\9_\Y"\rSR-5\:_\Y"\rSQ-5\8_\Y"\rST-5\;_\Y"\rSU-5\;_\Y"\rSV-5\;_\Y"\rSY-5\c_\Y"\rSI-5S_\Y"\rSJ-5S_\Y"\rSK-5S_\Y"\rS-5S_\Y"\rSP-5\d_\Y"\rSN-5\_\Y"\rSO-5\4_\Y"\rSa-5\4_\Y"\rS^-5\4_\Y"\rS`-5\4\Y"\rS_-5\4\Y"\rS]-5\\Y"\rSf-5\4\Y"\rSb-5\4\Y"\rSc-5\\Y"\rSe-5\\Y"\rS\-5\\Y"\rSg-5\\Y"\rSd-5\\Y"\rSL-5\\Y"\rSM-5\\Y"\rSX-5\\Y"\rS-5S\t\_0ErS\NS'\Eb\`\\u'\t\u4rSh\NS'O\t4r\Y"\rSP-5\g\Y"\rSa-5\p\Y"\rS`-5\n\Y"\rS_-5\q\Y"\rSb-5\o\Y"\rS]-5\h\Y"\rSc-5\j\Y"\rS\-5\l\Y"\rSe-5\i\Y"\rSf-5\f\Y"\rSg-5\k\Y"\rSd-5\m0 rS\NS'0rS\NS'\GRM\5 SSjrSSjr\)"S\!Sv9rSSjrSSjrSSSjjr"SS\W5r\"\5rS\NS'\GRM\]S\S\YS\^S05 SSjrg!\Fa SrEGNf=f)a This module defines the different types of terms. Terms are the kinds of objects that can appear in a quoted/asserted triple. This includes those that are core to RDF: * [Blank Nodes][rdflib.term.BNode] - Blank Nodes * [URI References][rdflib.term.URIRef] - URI References * [Literals][rdflib.term.Literal] - Literals (which consist of a literal value, datatype and language tag) Those that extend the RDF model into N3: * [`QuotedGraph`][rdflib.graph.QuotedGraph] - Formulae * [`Variable`][rdflib.term.Variable] - Universal Quantifications (Variables) And those that are primarily for matching against 'Nodes' in the underlying Graph: * REGEX Expressions * Date Ranges * Numerical Ranges ) annotationsN)Fraction) bind _is_valid_uriNodeIdentifiedNode IdentifierURIRefBNodeLiteralVariable) b64decode b64encode)hexlify unhexlify) defaultdict)datedatetimetime timedelta)Decimal)compilesub) GeneratorType) TYPE_CHECKINGAnyCallableDict GeneratorListOptionalTupleTypeTypeVarUnion) urldefragurljoinurlparse)uuid4) long_type)Durationduration_isoformatparse_datetime parse_timeparse_xsd_dateparse_xsd_duration)NamespaceManager)AlternativePathInvPath NegatedPathPath SequencePathFTzhttps://rdflib.github.ioz/.well-known/genid/z/.well-known/genid/rdflib/zDict[str, BNode]skolemsz <>" {}|\^`c,[H nX;dM g g)NFT)_invalid_uri_chars)urics E/home/james-whalen/.local/lib/python3.13/site-packages/rdflib/term.pyrrhs  8  z^[a-zA-Z]+(?:-[a-zA-Z0-9]+)*$c>[[RU55$N)bool_lang_tag_regexmatch)tags r=_is_valid_langtagrErs %%c* ++r>c[U[5(a[US5Sp!O[Up!U"U5 g![a gf=f)zO Verify that the provided value can be converted into a Python unicode object. decodeutf-8FT) isinstancebytesgetattrstr UnicodeError)value coding_funcparams r=_is_valid_unicoderQvsL %$UH5wU %UE  s5 AAcH\rSrSrSrSr\RSSSjj5rSr g)rzA Node in the Graph.Ncgr@rTselfnamespace_managers r=n3Node.n3sORr>r@rXzOptional[NamespaceManager]returnrL) __name__ __module__ __qualname____firstlineno____doc__ __slots__abcabstractmethodrY__static_attributes__rTr>r=rrsIRRr>rc\rSrSrSrSrSSjrSSjrSSjrSSjr SSjr SS jr SS jr SS jr SS jrSSS jjr\R"rSrg)r zYSee http://www.w3.org/2002/07/rdf-identifer-terminology/ regarding choice of terminology.rTc,[RX5$r@)rL__new__clsrNs r=riIdentifier.__new__s{{3&&r>c$URU5$)zFA "semantic"/interpreted equality function, by default, same as __eq____eq__rWothers r=eq Identifier.eq{{5!!r>c$URU5$)zGA "semantic"/interpreted not equal function, by default, same as __ne__)__ne__rps r=neqIdentifier.neqrtr>c.URU5(+$r@rnrps r=rvIdentifier.__ne__s;;u%%%r>c`[U5[U5La[U5[U5:H$g)a"Equality for Nodes. ```python >>> BNode("foo")==None False >>> BNode("foo")==URIRef("foo") False >>> URIRef("foo")==BNode("foo") False >>> BNode("foo")!=URIRef("foo") True >>> URIRef("foo")!=BNode("foo") True >>> Variable('a')!=URIRef('a') True >>> Variable('a')!=Variable('a') False ``` F)typerLrps r=roIdentifier.__eq__s*, :e $t9E * *r>cUcg[U5[U5La[U5[U5:$[U[5(a%[[U5[[U5:$[ $)zThis implements ordering for Nodes. This tries to implement this: http://www.w3.org/TR/sparql11-query/#modOrderBy Variables are not included in the SPARQL list, but they are greater than BNodes and smaller than everything else Tr|rLrIr _ORDERINGNotImplementedrps r=__gt__Identifier.__gt__s_ = $Z4; &t9s5z) ) t $ $T$Z(9T%[+AA Ar>cUcg[U5[U5La[U5[U5:$[U[5(a%[[U5[[U5:$[ $NFrrps r=__lt__Identifier.__lt__s] = $Z4; &t9s5z) ) t $ $T$Z(9T%[+AA Ar>c<URU5nU(agX:H$NT)rrWrqrs r=__le__Identifier.__le__ KK  }r>c<URU5nU(agX:H$r)rrs r=__ge__Identifier.__ge__rr>cH[U5R[U55$r@)rL startswith)rWprefixstartends r=rIdentifier.startswiths4y##CK00r>NrNrLrqrr\rA)..)rrLr\rA)r]r^r_r`rarbrirrrwrvrorrrrrrL__hash__rerTr>r=r r sK(I'" " &6$ 1||Hr>r c>\rSrSrSrSrSSjrS S SjjrS SjrSr g) rz An abstract class, primarily defined to identify Nodes that are not Literals. The name "Identified Node" is not explicitly defined in the RDF specification, but can be drawn from this section: https://www.w3.org/TR/rdf-concepts/#section-URI-Vocabulary rTc[U54$r@rLrWs r=__getnewargs__IdentifiedNode.__getnewargs__sD |r>Nc[5er@)NotImplementedErrorrVs r=rYIdentifiedNode.n3s !##r>c[U5$r@rrs r=toPythonIdentifiedNode.toPythons 4yr>)r\z Tuple[str]r@r[r\rL) r]r^r_r`rarbrrYrrerTr>r=rrs I$r>rc\rSrSr%SrSrS\S'S\S'S\S 'S \S 'SSS jjrSSSjjrSSjr \ SSj5r SSjr SSjr SSjrSSjrSSjrSSjrSrg )r i a[RDF 1.1's IRI Section](https://www.w3.org/TR/rdf11-concepts/#section-IRIs) !!! info "Terminology" Documentation on RDF outside of RDFLib uses the term IRI or URI whereas this class is called URIRef. This is because it was made when the first version of the RDF specification was current, and it used the term *URIRef*, see [RDF 1.0 URIRef](http://www.w3.org/TR/rdf-concepts/#section-Graph-URIref) An IRI (Internationalized Resource Identifier) within an RDF graph is a Unicode string that conforms to the syntax defined in RFC 3987. IRIs in the RDF abstract syntax MUST be absolute, and MAY contain a fragment identifier. IRIs are a generalization of URIs [RFC3986] that permits a wider range of Unicode characters. rTz8Callable[[URIRef, Union[URIRef, Path]], AlternativePath]__or__zCallable[[URIRef], InvPath] __invert__zCallable[[URIRef], NegatedPath]__neg__z5Callable[[URIRef, Union[URIRef, Path]], SequencePath] __truediv__NcPUb=URS5n[X!SS9nU(aURS5(dUS- n[U5(d[R US35 [ R X5nU$![a [ R XS5nU$f=f)N#r+)allow_fragmentszE does not look like a valid URI, trying to serialize this will break.rH)endswithr'rloggerwarningrLriUnicodeDecodeError)rkrNbase ends_in_hashrts r=riURIRef.__new__s   >>#.LD;E~~c**SLEU## NN'^_  2S(B " 2S1B  2s*B B%$B%c|[U5(d[SUS35eU(aURU5$SUS3$)zThis will do a limited check for valid URIs, essentially just making sure that the string includes no illegal characters (`<, >, ", {, }, |, \, `, ^`) Args: namespace_manager: if not None, will be used to make up a prefixed name "zk" does not look like a valid URI, I cannot serialize this as N3/Turtle. Perhaps you wanted to urlencode it?<>)r Exception normalizeUrirVs r=rY URIRef.n33sST""D6EF  $11$7 7tfA; r>cBSU;a[U5up[U5$U$)Nr)r&r )rWurlfrags r=defrag URIRef.defragFs# $;!$IC#; Kr>c,[U5R$)zReturn the URL Fragment ```python >>> URIRef("http://example.com/some/path/#some-fragment").fragment 'some-fragment' >>> URIRef("http://example.com/some/path/").fragment '' ``` )r(fragmentrs r=rURIRef.fragmentMs~&&&r>c&[[U544$r@)r rLrs r= __reduce__URIRef.__reduce__[sT %%r>cUR[LaSnOURRnUS[R U5S3$)Nzrdflib.term.URIRef()) __class__r r]rL__repr__rWclsNames r=rURIRef.__repr__^s? >>V #*Gnn--G!CLL./q11r>c<UR[U5U-5$r@rrLrps r=__add__URIRef.__add__f~~c$i%/00r>c<URU[U5-5$r@rrps r=__radd__URIRef.__radd__is~~ec$i/00r>c<UR[U5U-5$r@rrps r=__mod__URIRef.__mod__lrr>c([U[5(a/[U5n[UR[ [ 5SS9$[U[5(a+UnU[;a [U$[5nU[U'U$[SUS35e)zCreate a Blank Node from a skolem URI, in accordance with http://www.w3.org/TR/rdf11-concepts/#section-skolemization. This function accepts only rdflib type skolemization, to provide a round-tripping within the system. Added in version 4.0 NrNrz> is not a skolem URI) rI RDFLibGenidr(r pathlenrdflib_skolem_genidGenidr8r)rW parsed_uribnode_idretvals r= de_skolemizeURIRef.de_skolemizeos dK ( (!TF,Jzs3F/G/IJK K e $ $H7"x(($*! av%:;< r@)rNrLr Optional[str]r[)r\r r)r\zTuple[Type[URIRef], Tuple[str]])r\r )r]r^r_r`rarb__annotations__rirYrpropertyrrrrrrrrerTr>r=r r sg I DD++ ,,FF*& ' '&2111=r>r c,\rSrSrSr\SSj5rSrg)rirTc[U[5(d [U5n[U5nURR [ 5nUS:wagg)NrFT)rIrLr(rrfind skolem_genidr;rgen_ids r=_is_external_skolemGenid._is_external_skolemsB#s##c(Cc] &&|4 Q;r>Nr;rr\rA)r]r^r_r`rb staticmethodrrerTr>r=rrsIr>rc,\rSrSrSr\SSj5rSrg)rirTc[U[5(d [U5n[U5nURS:wd URS:wdUR S:wagUR R[5nUS:wagg)NFrT) rIrLr(paramsqueryrrrrrs r=_is_rdflib_skolemRDFLibGenid._is_rdflib_skolemsp#s##c(Cc]    #2%""b(&&':; Q;r>Nr)r]r^r_r`rbrrrerTr>r=rrsI  r>rcg)NNrTrTr>r= _unique_idrs r>c\rSrSrSrSrSS\"54S SjjrS S SjjrS Sjr SSjr SSS jjr Sr g)r ia3 RDF 1.1's Blank Nodes Section: https://www.w3.org/TR/rdf11-concepts/#section-blank-nodes Blank Nodes are local identifiers for unnamed nodes in RDF graphs that are used in some concrete RDF syntaxes or RDF store implementations. They are always locally scoped to the file or RDF store, and are not persistent or portable identifiers for blank nodes. The identifiers for Blank Nodes are not part of the RDF abstract syntax, but are entirely dependent on particular concrete syntax or implementation (such as Turtle, JSON-LD). --- RDFLib's `BNode` class makes unique IDs for all the Blank Nodes in a Graph but you should *never* expect, or reply on, BNodes' IDs to match across graphs, or even for multiple copies of the same graph, if they are regenerated from some non-RDFLib source, such as loading from RDF data. rTNcUc[Ub>[U5(aU"5nOUn[U[5(a [U5nOUnO[ 5R nX5-nO[ RX5$)z5 # only store implementations should pass in a value )callablerIrnextr)hexr ri)rkrN_sn_gen_prefix sn_resultnode_ids r=ri BNode.__new__sr ="G$$7>yI 'Ii77"9oG'G'++ *E !!#--r>c SU-$)Nz_:rTrVs r=rYBNode.n3s d{r>c&[[U544$r@)r rLrs r=rBNode.__reduce__sD |$$r>cUR[LaSnOURRnUS[R U5S3$)Nzrdflib.term.BNoderr)rr r]rLrrs r=rBNode.__repr__s? >>U ")Gnn--G!CLL./q11r>cjUc[nUc[nU[U5-n[[ X55$)zCreate a URIRef "skolem" representation of the BNode, in accordance with http://www.w3.org/TR/rdf11-concepts/#section-skolemization Added in version 4.0 )_SKOLEM_DEFAULT_AUTHORITYrrLr r')rW authoritybasepathskolems r= skolemizeBNode.skolemizes8  1I  *HCI%gi011r>)rNrrz-Optional[Union[Callable[[], str], Generator]]rrLr@r[)r\zTuple[Type[BNode], Tuple[str]]rNN)rrrrr\r ) r]r^r_r`rarbrrirYrrrrerTr>r=r r su$I $AE!| #.#.?#. #.J%2JN 2& 29F 2  2 2r>r c\rSrSr%SrS\S'S\S'S\S'S \S 'S rS,S-S jjrS.Sjr\ S/Sj5r \ S0Sj5r \ S1Sj5r \ S2Sj5r S3SjrS4SjrS5SjrS6SjrS6SjrS7SjrS.SjrS.SjrS.SjrS.SjrS8SjrS8SjrS8SjrS8S jrS8S!jrS9S"jrS8S#jrS8S$jrS8S%jr S:S;S&jjr!S<S=S'jjr"S>S(jr#S>S)jr$S0S*jr%S+r&g )?r i ad RDF 1.1's Literals Section: http://www.w3.org/TR/rdf-concepts/#section-Graph-Literal Literals are used for values such as strings, numbers, and dates. A literal in an RDF graph consists of two or three elements: * a lexical form, being a Unicode string, which SHOULD be in Normal Form C * a datatype IRI, being an IRI identifying a datatype that determines how the lexical form maps to a literal value, and * if and only if the datatype IRI is `http://www.w3.org/1999/02/22-rdf-syntax-ns#langString`, a non-empty language tag. The language tag MUST be well-formed according to section 2.2.9 of `Tags for identifying languages `_. A literal is a language-tagged string if the third element is present. Lexical representations of language tags MAY be converted to lower case. The value space of language tags is always in lower case. --- For valid XSD datatypes, the lexical form is optionally normalized at construction time. Default behaviour is set by `rdflib.NORMALIZE_LITERALS` and can be overridden by the normalize parameter to `__new__` Equality and hashing of Literals are done based on the lexical form, i.e.: ```python >>> from rdflib.namespace import XSD >>> Literal('01') != Literal('1') # clear - strings differ True ``` but with data-type they get normalized: ```python >>> Literal('01', datatype=XSD.integer) != Literal('1', datatype=XSD.integer) False ``` unless disabled: ```python >>> Literal('01', datatype=XSD.integer, normalize=False) != Literal('1', datatype=XSD.integer) True ``` Value based comparison is possible: ```python >>> Literal('01', datatype=XSD.integer).eq(Literal('1', datatype=XSD.float)) True ``` The eq method also provides limited support for basic python types: ```python >>> Literal(1).eq(1) # fine - int compatible with xsd:integer True >>> Literal('a').eq('b') # fine - str compatible with plain-lit False >>> Literal('a', datatype=XSD.string).eq('a') # fine - str compatible with xsd:string True >>> Literal('a').eq(1) # not fine, int incompatible with plain-lit NotImplemented ``` Greater-than/less-than ordering comparisons are also done in value space, when compatible datatypes are used. Incompatible datatypes are ordered by DT, or by lang-tag. For other nodes the ordering is None < BNode < URIRef < Literal Any comparison with non-rdflib Node are "NotImplemented" In PY3 this is an error. ```python >>> from rdflib import Literal, XSD >>> lit2006 = Literal('2006-01-01',datatype=XSD.date) >>> lit2006.toPython() datetime.date(2006, 1, 1) >>> lit2006 < Literal('2007-01-01',datatype=XSD.date) True >>> Literal(datetime.utcnow()).datatype rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#dateTime') >>> Literal(1) > Literal(2) # by value False >>> Literal(1) > Literal(2.0) # by value False >>> Literal('1') > Literal(1) # by DT True >>> Literal('1') < Literal('1') # by lexical form False >>> Literal('a', lang='en') > Literal('a', lang='fr') # by lang-tag False >>> Literal(1) > URIRef('foo') # by node-type True ``` The > < operators will eat this NotImplemented and throw a TypeError (py3k): ```python >>> Literal(1).__gt__(2.0) NotImplemented ``` r_valuer _languageOptional[URIRef] _datatypeOptional[bool] _ill_typed)rrrrNcUS:XaSnUbUO[RnUbUb [S5eUb([U5(d[ S[ U5S35eUb [ U5nSnSn[U[5(a>U=(d URnUb [X5nGO URnURnO[U[ 5(d[U[5(a[X5nUbGU[;a=[ U5n[R!U["5nU"X5n U=(d U (+nUb)U(a"[%XS5upU b['U 5(aU nOHUn[%X5upU cSO [ U 5n [R(R+X;5nU bU nUbSn[U[5(aUR-S5nU[.[04;a [3U5nU[04;a [5U5n[ R7X5n X,lX %:k/  Y$8$I!%*;F*C*C'-$%E 45E P F ) 1vi7HI{{,,XAH!#) # & . ./66w?  . ; ;45EF   } $=>NO  ?;;s5D! # " ?;;sg>D ?s H:: IIcrURb)[URURURS9$U$)a Returns a new literal with a normalised lexical representation of this literal ```python >>> from rdflib import XSD >>> Literal("01", datatype=XSD.integer, normalize=False).normalize() rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) ``` Illegal lexical forms for the datatype given are simply passed on ```python >>> Literal("a", datatype=XSD.integer, normalize=False) rdflib.term.Literal('a', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) ``` )r(r5)rNr r(r&rs r=r6Literal.normalizes.* :: !4:: DMMR RKr>cUR$)aQ For `recognized datatype IRIs `_, this value will be `True` if the literal is ill formed, otherwise it will be `False`. `Literal.value` (i.e. the `literal value `_) should always be defined if this property is `False`, but should not be considered reliable if this property is `True`. If the literal's datatype is `None` or not in the set of `recognized datatype IRIs `_ this value will be `None`. )rrs r=r7Literal.ill_typedsr>cUR$r@)rrs r=rN Literal.values {{r>cUR$r@)rrs r=r&Literal.language ~~r>cUR$r@)rrs r=r(Literal.datatyperEr>cR[[U5URUR44$r@)r rLr&r(rs r=rLiteral.__reduce__ s'  Y t}} 5  r>cBS[URURS94$)N)r&r()dictr&r(rs r= __getstate__Literal.__getstate__sdDMMDMMJKKr>c4Uup#USUlUSUlg)Nr&r()rr)rWarg_ds r= __setstate__Literal.__setstate__s::r>c UcU$[U[5(d [U5nUR[[4;aKUR[ ;a7UR 5nUR 5nX#-n[X@RS9$UR[:Xa{UR[ ;agUR 5nUR 5n[R"[SSS5U5U-n[UR5URS9$UR[;aUR[;djUR[;aUR[;dBUR[ ;aeUR[ ;dURUR:wa7[S[UR5S[UR535eURUR:Xa>[UR 5UR 5-URURS9$UR[ ;aUR[ ;ar[[#[%[#UR 55[#UR 55-S5SR'S5R'S 55[(S9$[R+X5nUR[.;a URn O[0n [XRU S9$![a$ [UR,5[U5-nNhf=f) a  ```python >>> from rdflib.namespace import XSD >>> Literal(1) + 1 rdflib.term.Literal('2', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) >>> Literal("1") + "1" rdflib.term.Literal('11') # Handling dateTime/date/time based operations in Literals >>> a = Literal('2006-01-01T20:50:00', datatype=XSD.dateTime) >>> b = Literal('P31D', datatype=XSD.duration) >>> (a + b) rdflib.term.Literal('2006-02-01T20:50:00', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) >>> from rdflib.namespace import XSD >>> a = Literal('2006-07-01T20:52:00', datatype=XSD.dateTime) >>> b = Literal('P122DT15H58M', datatype=XSD.duration) >>> (a + b) rdflib.term.Literal('2006-11-01T12:50:00', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) ``` r(r+z!Cannot add a Literal of datatype z to a Literal of datatype f0.)rIr r( _XSD_DATETIME _XSD_DATE_TIME_DELTA_TYPESr _XSD_TIMErcombinerr_ALL_DATE_AND_TIME_TYPESr$rLr&_NUMERIC_LITERAL_TYPESrroundrstrip _XSD_DECIMALrrN_STRING_LITERAL_TYPES _XSD_STRING) rWvaldate1duration differenceselfvvalvsdts new_datatypes r=rLiteral.__add__s0 ;K#w''#,C MMmY7 7 11+/==?E36<<>H)J: > >]]i 'CLL >  !99LL(@@ %==LL$<< !22\\):: 53C 4E3FF`adeiereras`tu  ==CLL ( #,,.0$--$--  MM3 3 66WT]]_5 8OOQSTUVW__f&   /KK* }} 55#}}  + 1mmlC C / Oc#h. /sL&&+MMc lUcU$[U[5(d [U5n[US5(d [S5e[US5(d [S5eUR[ [ 4;aKUR[;a7UR5nUR5nX#- n[X@RS9$UR[:Xa{UR[;agUR5nUR5n[R"[SSS5U5U- n[UR5URS9$URUR:XaUR[:Xa[R"[R"5UR55n[R"[R"5UR55n[Xx- [S9$[UR5UR5- UR UR[ [ [4;a[S9$URS9$UR[";aUR[";ar[[%['[%UR55[%UR55- S5SR)S 5R)S 55[*S9$[S [-UR5S [-UR535e) aImplements subtraction between Literals or between a Literal and a Python object. Example: ```python from rdflib.namespace import XSD # Basic numeric subtraction Literal(2) - 1 # rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) Literal(1.1) - 1.0 # rdflib.term.Literal('0.10000000000000009', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#double')) Literal(1.1) - 1 # rdflib.term.Literal('0.1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#decimal')) Literal(1.1, datatype=XSD.float) - Literal(1.0, datatype=XSD.float) # rdflib.term.Literal('0.10000000000000009', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#float')) # This will raise a TypeError Literal("1.1") - 1.0 # TypeError: Not a number; rdflib.term.Literal('1.1') Literal(1.1, datatype=XSD.integer) - Literal(1.0, datatype=XSD.integer) # rdflib.term.Literal('0.10000000000000009', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # Handling dateTime/date/time based operations in Literals a = Literal('2006-01-01T20:50:00', datatype=XSD.dateTime) b = Literal('2006-02-01T20:50:00', datatype=XSD.dateTime) (b - a) # rdflib.term.Literal('P31D', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#duration')) a = Literal('2006-07-01T20:52:00', datatype=XSD.dateTime) b = Literal('2006-11-01T12:50:00', datatype=XSD.dateTime) (a - b) # rdflib.term.Literal('-P122DT15H58M', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#duration')) (b - a) # rdflib.term.Literal('P122DT15H58M', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#duration')) ``` r(zCMinuend Literal must have Numeric, Date, Datetime or Time datatype.zFSubtrahend Literal must have Numeric, Date, Datetime or Time datatype.rUrVr+rWrXrYrZz&Cannot subtract a Literal of datatype z from a Literal of datatype )rIr rKr$r(r[r\r]rr^rr_rrtoday _XSD_DURATIONr&rarrbrcrdrL) rWrgrhrirjrkrlrmvdts r=__sub__Literal.__sub__sT ;K#w''#,CtZ((U j))X  MMmY7 7 11+/==?E36<<>H)J: > >]]i 'CLL > ==CLL (}} )&&tzz|T]]_E&&tzz|S\\^Dsy=AAMMOclln4MM ==]Iy,QQ&  "]]  MM3 3 66WT]]_5 8OOQSTUVW__f&  8S\\9J8KKghklplylyhzg{| r>cbURb[UR5$[U5S:g$)zXDetermines the truth value of the Literal. Used for if statements, bool(literal), etc. r)rNrArrs r=__bool__Literal.__bool__s+ :: ! # #4yA~r>c[UR[[[45(a#[ URR 55$[SU<35e)aImplements unary negation for Literals with numeric values. Example: ```python # Negating an integer Literal -Literal(1) # rdflib.term.Literal('-1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # Negating a float Literal -Literal(10.5) # rdflib.term.Literal('-10.5', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#double')) # Using a string with a datatype from rdflib.namespace import XSD -Literal("1", datatype=XSD.integer) # rdflib.term.Literal('-1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # This will raise a TypeError -Literal("1") # TypeError: Not a number; rdflib.term.Literal('1') ``` Not a number; )rIrNintr*floatr rr$rs r=rLiteral.__neg__sF0 djj3 5"9 : :4::--/0 0nTH56 6r>c[UR[[[45(a#[ URR 55$[SU<35e)aImplements unary plus operation for Literals with numeric values. Example: ```python # Applying unary plus to an integer Literal +Literal(1) # rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # Applying unary plus to a negative integer Literal +Literal(-1) # rdflib.term.Literal('-1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # Using a string with a datatype from rdflib.namespace import XSD +Literal("-1", datatype=XSD.integer) # rdflib.term.Literal('-1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # This will raise a TypeError +Literal("1") # TypeError: Not a number; rdflib.term.Literal('1') ``` r{)rIrNr|r*r}r __pos__r$rs r=rLiteral.__pos__sF. djj3 5"9 : :4::--/0 0nTH56 6r>c[UR[[[45(a#[ URR 55$[SU<35e)agImplements absolute value operation for Literals with numeric values. Example: ```python # Absolute value of a negative integer Literal abs(Literal(-1)) # rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # Using a string with a datatype from rdflib.namespace import XSD abs(Literal("-1", datatype=XSD.integer)) # rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # This will raise a TypeError abs(Literal("1")) # TypeError: Not a number; rdflib.term.Literal('1') ``` r{)rIrNr|r*r}r __abs__r$rs r=rLiteral.__abs__:sF& djj3 5"9 : :4::--/0 0nTH56 6r>c[UR[[[45(a#[ URR 55$[SU<35e)a[Implements bitwise NOT operation for Literals with numeric values. Example: ```python # Bitwise NOT of a negative integer Literal ~(Literal(-1)) # rdflib.term.Literal('0', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # Using a string with a datatype from rdflib.namespace import XSD ~(Literal("-1", datatype=XSD.integer)) # rdflib.term.Literal('0', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) # This will raise a TypeError ~(Literal("1")) # TypeError: Not a number; rdflib.term.Literal('1') ``` r{)rIrNr|r*r}r rr$rs r=rLiteral.__invert__RsF& djj3 5"9 : :4::0023 3nTH56 6r>cPUcg[U[5(GaaUR[;aiUR[;aUUR(dDUR(d3UR b&UR bUR UR :$[ RRUR[S9n[ RRUR[S9nX#:wa[ R(a[$X#:$URUR:wa=UR(dgUR(dgURUR:$UR bUR bx[UR 5[;aA[[UR 5nU"UR 5U"UR 5:$UR UR :$[!U5[!U5:wa[!U5[!U5:$URUR:wa5URcgURcgURUR:$g[U["5(ag[$![a Nf=f)a:Implements the greater-than comparison for Literals. This is the base method for ordering comparisons - other comparison methods delegate here. Implements the ordering rules described in http://www.w3.org/TR/sparql11-query/#modOrderBy In summary: 1. Literals with compatible data-types are ordered in value space 2. Incompatible datatypes are ordered by their datatype URIs 3. Literals with language tags are ordered by their language tags 4. Plain literals come before xsd:string literals 5. In the node order: None < BNode < URIRef < Literal Example: ```python from rdflib import XSD from decimal import Decimal # Comparing numeric literals in value space Literal(1) > Literal(2) # int/int # False Literal(2.0) > Literal(1) # double/int # True Literal(Decimal("3.3")) > Literal(2.0) # decimal/double # True Literal(Decimal("3.3")) < Literal(4.0) # decimal/double # True # Comparing string literals Literal('b') > Literal('a') # plain lit/plain lit # True Literal('b') > Literal('a', datatype=XSD.string) # plain lit/xsd:str # True # Incompatible datatypes ordered by DT Literal(1) > Literal("2") # int>string # False # Langtagged literals ordered by lang tag Literal("a", lang="en") > Literal("a", lang="fr") # False ``` TdefaultF)rIr r(rar7rNr"r.r/rfDAWG_LITERAL_COLLATIONrr&r|_TOTAL_ORDER_CASTERSr$rLr)rWrqdtselfdtothercasters r=rLiteral.__gt__ks` = eW % % MM%;;*@@..5??ZZ+ 0GzzEKK//[[**4==+*NFkk++ENNK+PG 00))!++}}.}} ==5>>99zz%%++*A #';;1$tzz2BCF!$**-u{{0CCC:: 334yCJ&4y3u:--}}.==( ^^+==5>>99 t $ $! !+!s$J J%$J%cUcg[U[5(a4URU5(+=(a URU5(+$[U[ 5(ag[ $![a [ s$f=fr)rIr rrrr$rrrps r=rLiteral.__lt__sm = eW % % &;;u--Ddggen2DD eT " "  &%% &s2A**A=<A=cURU5nU(agURU5$![a [s$f=f)zLess than or equal operator for Literals. Example: ```python from rdflib.namespace import XSD Literal('2007-01-01T10:00:00', datatype=XSD.dateTime) <= Literal('2007-01-01T10:00:00', datatype=XSD.dateTime) # True ``` T)rrrr$rrs r=rLiteral.__le__s@ KK   "775> ! "! ! " ,??cURU5nU(agURU5$![a [s$f=fr)rrrr$rrs r=rLiteral.__ge__s> KK   "775> ! "! ! "rc[U[5(aURbQURbDUR[;dUR[;aURUR:waggUR[:Xa6UR(d%UR[:XaUR(dgUR =(d SR 5UR =(d SR 5:wagg)zVHelper method to decide which things are meaningful to rich-compare with this literal.FrT)rIr r( XSDToPythonrfr&lowerrps r=_comparable_toLiteral._comparable_tos eW % %}}(U^^-GMM4~~[8}}6$ 4U^^NNk1$-- MM'R..0U^^5Ir4P4P4RR r>c[RU5nUR(a&U[URR 55-nUR bU[UR 5-nU$)aHash function for Literals to enable their use as dictionary keys. Example: ```python from rdflib.namespace import XSD a = {Literal('1', datatype=XSD.integer):'one'} Literal('1', datatype=XSD.double) in a # False ``` Notes: "Called for the key object for dictionary operations, and by the built-in function hash(). Should return a 32-bit integer usable as a hash value for dictionary operations. The only required property is that objects which compare equal have the same hash value; it is advised to somehow mix together (e.g., using exclusive or) the hash values for the components of the object that also play a part in comparison of objects." -- 3.4.1 Basic customization (Python) "Two literals are equal if and only if all of the following hold: * The strings of the two lexical forms compare equal, character by character. * Either both or neither have language tags. * The language tags, if any, compare equal. * Either both or neither have datatype URIs. * The two datatype URIs, if any, compare equal, character by character." -- 6.5.1 Literal Equality (RDF: Concepts and Abstract Syntax) )rLrrhashrr)rWress r=rLiteral.__hash__!sW>ll4  >> 4,,./ /C >> % 4' 'C r>cnXLagUcg[U[5(aURUR:H=(aw UR(aURR 5OSUR(aURR 5OS:H=(a [ R X5$g)a{Equality operator for Literals. Literals are only equal to other literals. Notes: "Two literals are equal if and only if all of the following hold: * The strings of the two lexical forms compare equal, character by character. * Either both or neither have language tags. * The language tags, if any, compare equal. * Either both or neither have datatype URIs. * The two datatype URIs, if any, compare equal, character by character." -- 6.5.1 Literal Equality (RDF: Concepts and Abstract Syntax) Example: ```python Literal("1", datatype=URIRef("foo")) == Literal("1", datatype=URIRef("foo")) # True Literal("1", datatype=URIRef("foo")) == Literal("1", datatype=URIRef("foo2")) # False Literal("1", datatype=URIRef("foo")) == Literal("2", datatype=URIRef("foo")) # False Literal("1", datatype=URIRef("foo")) == "asdf" # False from rdflib import XSD Literal('2007-01-01', datatype=XSD.date) == Literal('2007-01-01', datatype=XSD.date) # True Literal('2007-01-01', datatype=XSD.date) == date(2007, 1, 1) # False Literal("one", lang="en") == Literal("one", lang="en") # True Literal("hast", lang='en') == Literal("hast", lang='de') # False Literal("1", datatype=XSD.integer) == Literal(1) # True Literal("1", datatype=XSD.integer) == Literal("01", datatype=XSD.integer) # True ``` TNF)rIr rrrrLrorps r=roLiteral.__eq__HsV = = eW % %%//1,/3~~T^^))+4/4EOO))+DJ,JJt+  r>c[U[5(GaUR[;aUR[;aUR(dUR(dyUR blUR b_UR b&UR bUR UR :H$[ RX5(ag[SUSU35eUR=(d SR5UR=(d SR5:wag[RRUR[S9n[RRUR[S9nU[:XaU[:Xa[ RX5$U[;abU[;aXURSLaIURSLa:UR b-UR b [!UR UR 5$X#:wa;[R"(a%[SURSUR35egUR b&UR bUR UR :H$[ RX5(agUR[:Xag[SUSU35e[U[$5(ag[U[ 5(aDURbgUR[:Xd URc[ U5U:H$[F$[U[&[([*45(a*UR[;aUR U:H$[F$[U[,[.[045(a5UR[2[4[64;aUR U:H$[F$[U[8[:45(a5UR[<[>[@4;aUR U:H$[F$[U[B5(a#UR[D:XaUR U:H$[F$)a>Compare the value of this literal with something else. This comparison can be done in two ways: 1. With the value of another literal - comparisons are then done in literal "value space" according to the rules of XSD subtype-substitution/type-promotion 2. With a Python object: * string objects can be compared with plain-literals or those with datatype xsd:string * bool objects with xsd:boolean * int, long or float with numeric xsd types * date, time, datetime objects with xsd:date, xsd:time, xsd:datetime Any other operations returns NotImplemented. TzII cannot know that these two lexical forms do not map to the same value: z and rFrz4I don't know how to compare literals with datatypes )$rIr r(rar7rNrLror$r&rr"r.r/rf_XML_COMPARABLE_isEqualXMLNoderrr|r*r}rrrr[r\r^rr,rs_XSD_DAYTIMEDURATION_XSD_YEARMONTHDURATIONrA _XSD_BOOLEANr)rWrqrrs r=rr Literal.eqs eW % % MM%;;*@@..5??ZZ+ 0G::)ekk.E::44zz$..##''+fE%:  #**,1E20L0L0NN[[**4==+*NFkk++ENNK+PG$K)?zz$..?*w//I..,5??$3NZZ+ 0G&tzz5;;?? 00#Nt}}o]bchcqcqbrs! zz%%++*AzzU[[00::d**==K/  "V51 t $ $ s # #}}(}} +t}}/D4yE))0E*%Y6 7 7}} 66zzU**7"h5 6 6}} 9 EEzzU**F 84 5 5}}$&! zzU**  t $ $}} ,zzU**r>c.URU5(+$r@)rrrps r=rw Literal.neqs775>!!r>cbU(aURURS9$UR5$)aEReturns a representation in the N3 format. ```python >>> Literal("foo").n3() '"foo"' ``` Strings with newlines or triple-quotes: ```python >>> Literal("foo\nbar").n3() '"""foo\nbar"""' >>> Literal("''\'").n3() '"\'\'\'"' >>> Literal('"""').n3() '"\\"\\"\\""' ``` Language: ```python >>> Literal("hello", lang="en").n3() '"hello"@en' ``` Datatypes: ```python >>> Literal(1).n3() '"1"^^' >>> Literal(1.0).n3() '"1.0"^^' >>> Literal(True).n3() '"true"^^' ``` Datatype and language isn't allowed (datatype takes precedence): ```python >>> Literal(1, lang="en").n3() '"1"^^' ``` Custom datatype: ```python >>> footype = URIRef("http://example.org/ns#foo") >>> Literal("1", datatype=footype).n3() '"1"^^' ``` Passing a namespace-manager will use it to abbreviate datatype URIs: ```python >>> from rdflib import Graph >>> Literal(1).n3(Graph().namespace_manager) '"1"^^xsd:integer' ``` )qname_callback) _literal_n3rrVs r=rY Literal.n3s2F ##3D3Q3Q#R R##% %r>cU(GaUR[;aURbUR[;aU[ U5n[ R "U5(d[ R"U5(aURSU5$UR[:Xa[SS[ U5S5$UR[:XaUnSU;aSU;a SU;aUS- nU$UR[:XaUR5$U$UR5nURnSnUbU(aU"U5nU(dSUS 3nU[;av[ U5n[ R "U5(a"UR!S S 5R!S S 5n[ R"U5(aUR!S S5nUR&nU(aUSU3$U(aUSU3$U$![a URSU5s$f=f![a ["R$"SU<35 Nrf=f)aSInternal method for N3 serialization with more options. Args: use_plain: Whether to use plain literal (shorthand) output qname_callback: Function to convert URIs to prefixed names Example: Using plain literal (shorthand) output: ```python >>> from rdflib.namespace import XSD >>> Literal(1)._literal_n3(use_plain=True) '1' >>> Literal(1.0)._literal_n3(use_plain=True) '1e+00' >>> Literal(1.0, datatype=XSD.decimal)._literal_n3(use_plain=True) '1.0' >>> Literal(1.0, datatype=XSD.float)._literal_n3(use_plain=True) '"1.0"^^' >>> Literal("foo", datatype=XSD.string)._literal_n3(use_plain=True) '"foo"^^' >>> Literal(True)._literal_n3(use_plain=True) 'true' >>> Literal(False)._literal_n3(use_plain=True) 'false' >>> Literal(1.91)._literal_n3(use_plain=True) '1.91e+00' ``` Only limited precision available for floats: ```python >>> Literal(0.123456789)._literal_n3(use_plain=True) '1.234568e-01' >>> Literal('0.123456789', datatype=XSD.decimal)._literal_n3(use_plain=True) '0.123456789' ``` Using callback for datatype QNames: ```python >>> Literal(1)._literal_n3(qname_callback=lambda uri: "xsd:integer") '"1"^^xsd:integer' ``` NFz\.?0*eerZEz.0rrinfINFInfinitynanNaNzSerializing weird numerical @z^^)r(_PLAIN_LITERAL_TYPESrN_NUMERIC_INF_NAN_LITERAL_TYPESr}mathisinfisnanrr% _XSD_DOUBLErrdrr _quote_encodereplacewarningswarnr&) rW use_plainrvrnencodedr( quoted_dtr&s r=rLiteral._literal_n3Cs| *>>zz%==$BBG!$K::a==DJJqMM#'#3#3E>#JJ-:==K/y#%+aBB]]l2&A!|1 AT H]]l2"V??,,"V$))+==  *84 zO 99 Kd Azz!}}#*//%"?"G"G&#zz!}}")//%"? == Yaz* * Yb , ,Nc&G#//~FFGL"KMM$@"IJKs%AG>A5H >HH $IIcPSU;a\URSS5nSU;aURSS5nUSS:XaUSS:wa USSS-S-nS URS S 5-$S URSS 5RSS5RSS5RS S 5-$)N \z\\z"""z\"\"\"rz"""%s""" z\rz"%s"z\nz\")r)rWrs r=rLiteral._quote_encodes 4<ll40G}!//%=r{c!gbkT&9!#2,-3e << <DLLu5==dFKSSUgdE"# #r>c[RU5/nURb'URS[ UR5-5 UR b'URS[ UR 5-5 UR [:XaSnOUR RnUSSRU5S3$)Nzlang=z datatype=zrdflib.term.Literalrz, r) rLrr&appendreprr(rr r]join)rWargsrs r=rLiteral.__repr__s T"# == $ KK$t}}"55 6 == $ KK d4==&99 : >>W $+Gnn--G!DIIdO,A..r>c8URb UR$U$)zF Returns an appropriate python datatype derived from this RDF Literal rrs r=rLiteral.toPythons :: !::  r>)rr)NNN)r4rr5rr(rr6r)r\r )r\r)r\r)r\r)r\r)r\zDTuple[Type[Literal], Tuple[str, Union[str, None], Union[str, None]]])r\z(Tuple[None, Dict[str, Union[str, None]]])rOzTuple[Any, Dict[str, Any]]r\None)rgrr\r )r\rAr)r\r|r@r[)FN)rrArz+Optional[Callable[[URIRef], Optional[str]]]r\rLr)'r]r^r_r`rarrbrir6rr7rNr&r(rrLrRrrurxrrrrrrrrrrrorrrwrYrrrrrerTr>r=r r spjX KBI #"&$( VVV V " Vp4   M L' iDVob7:787072n"` "$"<%N8ttl"F&T FJxxDx xt#6 /r>r c[RRRSUS35nUR 5 U$)Nzz)xmldomminidom parseStringr6) xmlstringrs r= _parseXMLrs: WW__ ( ( !),DEF  Mr>c.[R"[RRS5SS9nUR U5nUR5 U$![R R an[RSU35 UeSnAff=f)aE Parse the lexical form of an HTML literal into a document fragment using the `dom` from html5rdf tree builder. Args: lexical_form: The lexical form of the HTML literal. Returns: A document fragment representing the HTML literal. Raises: html5rdf.html5parser.ParseError: If the lexical form is not valid HTML. rT)treestrictzFailed to parse HTML: N) html5rdf HTMLParser treebuildersgetTreeBuilder parseFragment html5parser ParseErrorrinfor6) lexical_formparserresultrs r= _parse_htmlrs  " " 1 1% 8F393G3G 3U  M    * * ,QC01sAB5BBc0[R"USS9nU$)z Serialize a document fragment representing an HTML literal into its lexical form. Args: value: A document fragment representing an HTML literal. Returns: The lexical form of the HTML literal. r)r)r serialize)rNrs r= _write_htmlrs  E 2F Mr>c[U[RRR5(aI[RRR 5nU=R UR - slUnURS5nURS5(aUSSnURS5(aUSSnUS:XaSnU$) NrHs&&sisr>) rIrrrDocumentFragmentDocument childNodestoxmlr)xmlnoderQrns r= _writeXMLrs'377??;;<< GGOO $ $ & ***  gA ||=>> bcF||.// bI ''  Hr>cb[U[5(aUR5n[U5$r@)rIrLencoderrs r= _unhexlifyr3s%%  U r>c/SQn/SQnUR5nX1;agX2;a[R"SU<S3[S9 g) Boolean is a datatype with value space {true,false}, lexical space {"true", "false","1","0"} and lexical-to-value mapping {"true"→true, "false"→false, "1"→true, "0"→false}. )1true1true)rYfalse0falseTzParsing weird boolean, z does not map to True or False)categoryF)rrr UserWarning)rNtrue_accepted_valuesfalse_accepted_values new_values r= _parseBooleanr :sK 8: I(- %eY.L M   r>c USL$)a6 This function is used as the fallback for detecting ill-typed/ill-formed literals and operates on the asumption that if a value (i.e. `Literal.value`) could be determined for a Literal then it is not ill-typed/ill-formed. This function will be called with `Literal.lexical` and `Literal.value` as arguments. NrTlexicalrNs r=r,r,Ms  r>cd[U5S:=(a [U[5=(a US:$)z? xsd:unsignedInteger and xsd:unsignedLong must not be negative r)rrIr*r s r=_well_formed_unsignedlongrYs( wc US;$)r)rrrrrrrYrrTr s r=_well_formed_booleanr`s P PPr>c[U5S:=(a, [U[5=(a SUs=:*=(a S:*$s $)z The value space of xs:int is the set of common single size integers (32 bits), i.e., the integers between -2147483648 and 2147483647, its lexical space allows any number of insignificant leading zeros. riirrIr|r s r=_well_formed_intrisC G q 1 uc " 1 E / /Z /0r>c[U5S:=(a, [U[5=(a SUs=:*=(a S:*$s $)z? xsd:unsignedInt has a 32bit value of between 0 and 4294967295 rlrr s r=_well_formed_unsignedintrvs7 wc[U5S:=(a, [U[5=(a SUs=:*=(a S:*$s $)z The value space of xs:short is the set of common short integers (16 bits), i.e., the integers between -32768 and 32767, its lexical space allows any number of insignificant leading zeros. riirr s r=_well_formed_shortr}s7 wc[U5S:=(a, [U[5=(a SUs=:*=(a S:*$s $)z< xsd:unsignedShort has a 16bit value of between 0 and 65535 rirr s r=_well_formed_unsignedshortrs7 wc[U5S:=(a, [U[5=(a SUs=:*=(a S:*$s $)z The value space of xs:byte is the set of common single byte integers (8 bits), i.e., the integers between -128 and 127, its lexical space allows any number of insignificant leading zeros. rirr s r=_well_formed_byters7 wc[U5S:=(a, [U[5=(a SUs=:*=(a S:*$s $)z8 xsd:unsignedByte has a 8bit value of between 0 and 255 rrr s r=_well_formed_unsignedbyter s7 wc:[U[5=(a US:$NrrIr|r s r=!_well_formed_non_negative_integerr$ eS ! 0eqj0r>c:[U[5=(a US:$r"r#r s r=_well_formed_positive_integerr' eS ! /eai/r>c:[U[5=(a US:*$r"r#r s r=!_well_formed_non_positive_integerr*r%r>c:[U[5=(a US:$r"r#r s r=_well_formed_negative_integerr,r(r>z!http://www.w3.org/2001/XMLSchema#z+http://www.w3.org/1999/02/22-rdf-syntax-ns# XMLLiteralHTMLstringnormalizedStringtokenr}doubledecimalintegerbooleandateTimerrridayTimeDurationyearMonthDurationz&http://www.w3.org/2002/07/owl#rational base64Binary hexBinarygYear gYearMonthbyter|longnegativeIntegernonNegativeIntegernonPositiveIntegerpositiveIntegershort unsignedByte unsignedInt unsignedLong unsignedShortzTuple[URIRef, ...]rarr_DATE_AND_TIME_TYPESr]r`cjURSL=(a URRU5SLU4$r@tzinfo utcoffsetrs r=rMs/ D NU\\%;%;E%B$%N r>cjURSL=(a URRS5SLU4$r@rJrs r=rMrM s/ D MU\\%;%;D%A%M r>c"UR5$r@)rrs r=rMrMs EKKMr>z%Dict[Type[Any], Callable[[Any], Any]]rre_StrT)boundc0Ub U"U5U4$UbX4$US4$r@rT)objpTypecastFuncdTypes r= _py2literalrWs1 }e##  zDyr>c[H-uup#n[X5(dMX1:XdM![XXC5s $ [H&unupC[X5(dM[XXC5s $ US4$)zx Casts a tuple of a python type and a special datatype URI to a tuple of the lexical value and a datatype URI (or None) N)_SpecificPythonToXSDRulesrIrW_GenericPythonToXSDRules)rSr(rTrVrUs r=r-r-+sj%>  c ! !e&7s8; ;%>%=   c ! !s8; ;%= 9r>rc4[U5R5$r@)rLris r=rMrMNsc!fllnr>c US$)NrXrTr\s r=rMrMQs Aa5r>c"UR5$r@ isoformatr\s r=rMrMRs !++-r>c"UR5$r@r`r\s r=rMrMS akkmr>c"UR5$r@r`r\s r=rMrMTrcr>c[U5$r@r-r\s r=rMrMUs ,Q/r>c[U5$r@rfr\s r=rMrMVs -a0r>zZList[Tuple[Type[Any], Tuple[Optional[Callable[[Any], Union[str, bytes]]], Optional[str]]]]rZcBURS5RS5$)Nz%Ystrftimezfillrgs r=rMrMlsS\\$%7%=%=a%@r>cBURS5RS5$)Nz%Y-%mrjrms r=rMrMms#,,w*?*E*Ea*Hr>zPList[Tuple[Tuple[Type[Any], str], Optional[Callable[[Any], Union[str, bytes]]]]]rYr&anyURIz3Dict[Optional[str], Optional[Callable[[str], Any]]]rrz6Dict[URIRef, Callable[[Union[str, bytes], Any], bool]]r*r)c[R5 [R[5 [R5 [R [ 5 [R5 [R [5 g)z2Reset lexical<->value space binding for `Literal`.N) r)clearupdaterrZextend _OriginalGenericPythonToXSDRulesrY!_OriginalSpecificPythonToXSDRulesrTr>r=_reset_bindingsrwsRK(""$##$DE##%$$%FGr>c[UnUb U"U5$[ U5$![a gf=f![a [R SUSU3SS9 gf=f![ a [ US5s$f=f)ztMap a lexical form to the value-space for the given datatype. Returns: A python object for the value or `None` Nz:Failed to convert Literal lexical form to value. Datatype=z , Converter=T)exc_inforH)r)KeyErrorrrrrLr)r r( conv_funcs r=r'r's$X.   W% % )w< -   NNLXJVbclbmn     " )w( (  )s, #3 A 00$AAA65A6_AnyTc[U[5(a2URSS5RSS5RSS5$U$)zxReplaces \t, \n, \r (#x9 (tab), #xA (linefeed), and #xD (carriage return)) with space without any whitespace collapsing.  rr)rIrLrr4s r=r2r2sF"C(( ''c2::4EMMdTWXX r>c|[U[5(a&[R"SSUR 55$U$)Nz +r)rIrLrerstriprs r=r3r3s5"C((vvdC!1!7!7!9:: r>cU(aUc [S5eU[;a[RSUS35 UcUnU[U'U(a[R X4U45 g[ R XU445 g)a  register a new datatype<->pythontype binding Args: constructor: An optional function for converting lexical forms into a Python instances, if not given the pythontype is used directly lexicalizer: An optional function for converting python objects to lexical form, if not given object.__str__ is used datatype_specific: Makes the lexicalizer function be accessible from the pair (pythontype, datatype) if set to True or from the pythontype otherwise. False by default Nz1No datatype given for a datatype-specific bindingz datatype 'z' was already bound. Rebinding.)rr)rrrYrrZ)r( pythontype constructor lexicalizerdatatype_specifics r=rrs|(X-KLL##H:-LMN !,X!((:*@+)NO ''85L(MNr>cR\rSrSrSrSrS SjrS SjrS SjrS S Sjjr SS jr Sr g)r i! zc A Variable - this is used for querying, or in Formula aware graphs, where Variables can be stored rTc|[U5S:Xa [S5eUSS:XaUSSn[RX5$)Nrz7Attempted to create variable with empty string as name!?r+)rrrLrirjs r=riVariable.__new__) s> u:?UV V 8s?!"IE{{3&&r>cUR[LaSnOURRnUS[R U5S3$)Nzrdflib.term.Variablerr)rr r]rLrrs r=rVariable.__repr__0 s? >>X %,Gnn--G!CLL./q11r>c SU-$NrrTrs r=rVariable.toPython8 Tzr>Nc SU-$rrTrVs r=rY Variable.n3; rr>c&[[U544$r@)r rLrs r=rVariable.__reduce__> s3t9,''r>rrr@r[)r\z!Tuple[Type[Variable], Tuple[str]]) r]r^r_r`rarbrirrrYrrerTr>r=r r ! s' I'2(r>r zDict[Type[Node], int]r (c ^^SSKJn UU4SjnTbTcgTRTR:wagTRURUR4;aU"5$TRUR :XGav[ (aj[T[RRR5(de[T[RRR5(deTRTR:XaTRTR:XdgTRR5Vs/sHnUSS:wdMUPM nnTRR5Vs/sHnUSS:wdMUPM nn[!U5[!U5:wagUH<nXF;a4TR#USUS5TR#USUS5:XaM< g U"5$TRUR$UR&UR(UR*4;Gac[ (Ga>[T[RRR,[RRR.[RRR0[RRR245(de[T[RRR,[RRR.[RRR0[RRR245(deTR4TR4:H$TRUR6:Xa[ (aj[T[RRR85(de[T[RRR85(deTR4TR4:H=(a TR:TR::H$TRUR<:XaTR>TR>:H$TRUR@:Xa[ (aj[T[RRRB5(de[T[RRRB5(deTRDTRD:H=(a TRFTRF:H$[ISTR35es snfs snf)Nr)rc>[TR5[TR5:wag[STRTR5Hup[X5(aM g g)NFcX4$r@rT)xys r=rM2_isEqualXMLNode..recurse..t svr>T)rrmapr)ncocnoderqs r=recurse _isEqualXMLNode..recursej sX t 3u'7'7#8 8-t@P@PQFB"2**Rr>Fzhttp://www.w3.org/2000/xmlns/r+z*I dont know how to compare XML Node type: )%xml.dom.minidomrnodeType DOCUMENT_NODEDOCUMENT_FRAGMENT_NODE ELEMENT_NODErrIrrrElementtagName namespaceURI attributeskeysNSrgetAttributeNS TEXT_NODE COMMENT_NODECDATA_SECTION_NODE NOTATION_NODETextComment CDATASectionNotationdataPROCESSING_INSTRUCTION_NODEProcessingInstructiontarget ENTITY_NODE nodeValueDOCUMENT_TYPE_NODE DocumentTypepublicIdsystemIdr)rrqXMLNoderkn_keyso_keyss`` r=rrJ s<0  |u} }}& }}..0N0NOOy '.. . =dCGGOO$;$;<< <<eSWW__%<%<== == LLEMM )d.?.?5CUCU.U__++- -t66 -  %%,,. .t66 .  v;#f+ %A ''!ad3u7K7KAaDRSTURV7WW y ""   =GGOO((GGOO++GGOO00GGOO,,  GGOO((GGOO++GGOO00GGOO,,  yyEJJ&& '== = =dCGGOO$I$IJJ JJeSWW__%J%JKK KKyyEJJ&F4;;%,,+FF '-- -~~00 '44 4 =dCGGOO$@$@AA AAeSWW__%A%ABB BB}}.R4==ENN3RRDT]]OTUUI  s U+U+5 U0U0)r;rLr\rA)rDrLr\rA)rNUnion[str, bytes]r\rAr)rrLr\zxml.dom.minidom.Document)rrLr\ xml.dom.minidom.DocumentFragment)rNrr\rJ)rzAUnion[xml.dom.minidom.Document, xml.dom.minidom.DocumentFragment]r\rJ)rNzUnion[str, bytes, Literal]r\rJ)r rrNrr\rA) rSrrTrrUzOptional[Callable[[Any], Any]]rVzOptional[_StrT]r\zTuple[Any, Optional[_StrT]])rSrr(rr\zTuple[Any, Optional[str]])r\r)r rr(rr\r)r4r|r\r|)NNF) r(rLrz Type[Any]rzOptional[Callable[[str], Any]]rz,Optional[Callable[[Any], Union[str, bytes]]]rrAr\r)rUnion[None, xml.dom.minidom.Attr, xml.dom.minidom.Comment, xml.dom.minidom.Document, xml.dom.minidom.DocumentFragment, xml.dom.minidom.DocumentType, xml.dom.minidom.Element, xml.dom.minidom.Entity, xml.dom.minidom.Notation, xml.dom.minidom.ProcessingInstruction, xml.dom.minidom.Text]rqrr\rA)ra __future__rrcr fractionsr__all__loggingrrrrbase64rrbinasciirr collectionsrrrrrr3rrrtypesrtypingrrrrrr r!r"r#r$r% urllib.parser&r'r(uuidr)r" rdflib.util rdflib.compatr* xsd_datetimer,r-r.r/r0r1 namespacer2pathsr3r4r5r6r7 _HAS_HTML5RDFr ImportErrorr getLoggerr]rrrr8rr:rrBrErQABCrrLr rr rrrr r rrrrrr r,rrrrrrrr r$r'r*r,_XSD_PFX_RDF_PFX_RDF_XMLLITERAL_RDF_HTMLLITERALrfr0r1 _XSD_FLOATrrd _XSD_INTEGERrr[r\r^rsrr _OWL_RATIONAL_XSD_B64BINARY_XSD_HEXBINARY _XSD_GYEAR_XSD_GYEARMONTHrarrrHr]r`rrrrrerPrWr-r}rAr|rZrrlistrurJrYrvrrr*r)rsrwr'r|r2r3rr rrrTr>r=rsq ,#   ''#44    65 #+PP M7   8 $$ 2 #9:,$S377ScscLZ&y=^y=x F %( U2NU2p^j^B'4  N   (& LQ VVQRO1010 / 8L01(V+,X() += => Hw& ' Hw& ' X() h*+ h*+ h*+ x*,- 8f$ % 8f$ % x*,- h)::;+> >??@ >12;./ Hw& ' L01 8g  8f  8e  8f  8' '( 8* *+ 8* *+ 8' '( 8g  8n $% 8m #$ 8n $% 8o %&!.** ,( 8g 6 2  ,()% 0DFW/W,W      GGOO9 ?;   8( () 8g  -) s#     -    !  %B , T;   $l 344 |$% !<01 '78 #Y /0 #Y /0 /?@02FGHWW__ ?;< m$%$ ##  ) )K9I+JK$((@#A  J@A OHI >G$ ^g& >I& ^i(  %))B$C!!D$!D 8f z!D 8f ~!D 8j !> !D  8j !#5 !D  8' '(*< !D 8) )*,>!D 8k !"J!D 8h !D 8( ()4!D 8g !D 8j !4!D 8i  -!D 8i  '!D 8i  )!D  8* *+Y!!D" 8f y#!D$ 8* *+Y 8' '() 8e c 8n $%y 8' '() 8g  8m #$c 8f s 8o %& 8n $%s 8g  8h  8n $%y 8h YA!D @!F %0K !+: 8n $%'@ 8o %&(B 8n $%'@ TP IKEJ $ H%) %)*:%)%)P s#37@D# O O O0 O> O  O  OF(z(J$/s#3 3 %Xr62wCDKV KV KV6 7KVaGHs]%%]10]1