PieUdZddlmZddlZddlZddlmZgdZddlZddl Z ddl Z ddl Z ddl mZmZddlmZmZddlmZdd lmZmZmZmZdd lmZdd lmZmZdd lmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0ddl1Z1ddl2Z1ddl3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;e rddlm?Z?m@Z@mAZAmBZBmCZCdZD ddlEZEdZDn #eF$rdZEYnwxYwdZGejHeIZJdZKdZLiZMdeNd<dZOdd!ZPed"ZQdd$ZRdd'ZSGd(d)ejTZUGd*d+eUeVZWGd,d-eWZXGd.d/eXZYGd0d1eYZZGd2d3eZZ[dd4Z\Gd5d6eXZ]Gd7d8eWZ^dd;Z_dd>Z`dd@ZaddCZbddEZcddFZdddIZeddJZfddKZgddLZhddMZiddNZjddOZkddPZlddQZmddRZnddSZoddTZpddUZqdVZrdWZseYesdXzZteYesdYzZueYerdZzZveYerd[zZweYerd\zZxeYerd]zZyeYerd^zZzeYerd_zZ{eYerd`zZ|eYerdazZ}eYerdbzZ~eYerdczZeYerddzZeYerdezZeYerdfzZeYerdgzZeYdhZeYerdizZeYerdjzZeYerdkzZeYerdlzZe|e{ezeYerd]zeYerdmzeYerdnzeYerdozeYerdpzeYerdqzeYerdrzeYerdszeYerdtzeYerduzeYerdvzeYerdwzeYerdxzfZdyeNdz<e|e}eze{efZdyeNd{<eYerd]zeze{fZdyeNd|<e~eefZdyeNd}<eefZdyeNd~<eezZdyeNd<edede jjjdiZdeNd<eveteueYerd[zeYerd\zfZdyeNd<e)deVZddZddZeVdfedezffede}ffede|ffe4de|ffede{ffede~ffedeffedeffe6deffedeffe jjjebetffedeffg ZdeNd<eE(ee jjjeaeuffeeZeefdfeefdfeVefefeefefeVefefeefefgZdeNd<eeZiddeYerddze9eYerdcze:eYerdbze8eYerdeze;eYerdfze;eYerdgze;eYerdjzeceYerdZzdeYerd[zdeYerd\zdeYerdzdeYerdazedeYerd_zeeYerd`ze4eYerdrze4eYerdoze4eYerdqze4eYerdpze4eYerdnzeeYerdwze4eYerdsze4eYerdtzeeYerdvzeeYerdmzeeYerdxzeeYerduzeeYerd]zeeYerd^zeeYerdizeeYerdzdete_iZdeNd<eEe`eeu<eteufZdyeNd<netfZeYerdazegeYerdrzepeYerdqzeneYerdpzeqeYerdszeoeYerdnzeheYerdtzejeYerdmzeleYerdvzeieYerdwzefeYerdxzekeYerduzemi ZdeNd<iZdeNd<eeddZddZe)de!ZddZddZ dddZGddeWZeeZdeNd<ee]dedeYde^diddńZdS)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 <>" {}|\^`uristrreturnboolc(tD] }||vrdS dS)NFT)_invalid_uri_chars)r9cs _/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/rdflib/term.pyrrhs+  8855  4z^[a-zA-Z]+(?:-[a-zA-Z0-9]+)*$tagcPtt|SN)r<_lang_tag_regexmatch)rBs r@_is_valid_langtagrGrs %%c** + ++rAvalueUnion[str, bytes]ct|trt|dd}}n t|}} ||n#t$rYdSwxYwdS)z[ Verify that the provided value can be converted into a Python unicode object. decodeutf-8FT) isinstancebytesgetattrr: UnicodeError)rH coding_funcparams r@_is_valid_unicoderSvss %($UH55wU  %U  E uu 4s ? A  A c:eZdZdZdZejd d dZdS) rzA Node in the Graph.Nnamespace_managerOptional[NamespaceManager]r;r:cdSrDrUselfrVs r@n3zNode.n3sORsrArDrVrWr;r:)__name__ __module__ __qualname____doc__ __slots__abcabstractmethodr[rUrAr@rrs8IRRRRRRRrArcveZdZdZdZddZdd Zdd Zdd Zdd Z ddZ ddZ ddZ ddZ dddZejZdS)r z]See http://www.w3.org/2002/07/rdf-identifer-terminology/ regarding choice of terminology.rUrHr:c8t||SrD)r:__new__clsrHs r@rfzIdentifier.__new__s{{3&&&rAotherrr;r<c,||S)zNA "semantic"/interpreted equality function, by default, same as __eq____eq__rZris r@eqz Identifier.eq{{5!!!rAc,||S)zOA "semantic"/interpreted not equal function, by default, same as __ne__)__ne__rms r@neqzIdentifier.neqrorAc.|| SrDrkrms r@rqzIdentifier.__ne__s;;u%%%%rAct|t|ur t|t|kSdS)aEquality 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)typer:rms r@rlzIdentifier.__eq__s7, ::e $ $t99E * *5rAc*|dSt|t|ur t|t|kSt|tr6tt|tt|kSt S)a This 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 NTrur:rMr _ORDERINGNotImplementedrms r@__gt__zIdentifier.__gt__sv =4 $ZZ4;; & &t99s5zz) ) t $ $ BT$ZZ(9T%[[+AA ArAc*|dSt|t|ur t|t|kSt|tr6tt|tt|kSt SNFrwrms r@__lt__zIdentifier.__lt__st =5 $ZZ4;; & &t99s5zz) ) t $ $ BT$ZZ(9T%[[+AA ArAc@||}|rdS||kSNT)r}rZrirs r@__le__zIdentifier.__le__* KK    4u}rAc@||}|rdS||kSr)rzrs r@__ge__zIdentifier.__ge__rrA.prefixc`t|t|SrD)r: startswith)rZrstartends r@rzIdentifier.startswiths"4yy##CKK000rANrHr:rirr;r<)..)rr:r;r<)r]r^r_r`rarfrnrrrqrlrzr}rrrr:__hash__rUrAr@r r s((I''''"""" """" &&&&6$ 11111|HHHrAr c0eZdZdZdZd dZd dd Zdd ZdS)ra  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 rUr; Tuple[str]c"t|fSrDr:rZs r@__getnewargs__zIdentifiedNode.__getnewargs__sD |rANrVrWr:ctrD)NotImplementedErrorrYs r@r[zIdentifiedNode.n3s!###rAc t|SrDrrs r@toPythonzIdentifiedNode.toPythons4yyrA)r;rrDr\r;r:)r]r^r_r`rarr[rrUrAr@rrsf I$$$$$rArceZdZUdZdZded<ded<ded<d ed <dd dZdd!dZd"dZe d#dZ d$dZ d#dZ d"dZ d"dZd"dZd%dZd S)&r 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. rUz8Callable[[URIRef, Union[URIRef, Path]], AlternativePath]__or__zCallable[[URIRef], InvPath] __invert__zCallable[[URIRef], NegatedPath]__neg__z5Callable[[URIRef, Union[URIRef, Path]], SequencePath] __truediv__NrHr:base Optional[str]cz|C|d}t||d}|r|ds|dz }t|st|d t ||}n,#t$rt ||d}YnwxYw|S)N#r+)allow_fragmentszE does not look like a valid URI, trying to serialize this will break.rL)endswithr'rloggerwarningr:rfUnicodeDecodeError)rhrHr ends_in_hashrts r@rfzURIRef.__new__s   >>#..LD%;;;E !~~c**!SLEU##  NN___    2S%((BB! 2 2 2S%11BBB 2 s3B&B87B8rVrWr;ct|std|d|r||Sd|dS)aThis 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 normalizeUrirYs r@r[z URIRef.n33slT"" FDFFF   $11$77 7t;;; rAcPd|vr!t|\}}t|S|S)Nr)r&r )rZurlfrags r@defragz URIRef.defragFs+ $;;!$IC#;; KrAc*t|jS)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@rzURIRef.fragmentMs~~&&rATuple[Type[URIRef], Tuple[str]]c0tt|ffSrD)r r:rs r@ __reduce__zURIRef.__reduce__[sT %%rAc||jturd}n |jj}|dt|dS)Nzrdflib.term.URIRef()) __class__r r]r:__repr__rZclsNames r@rzURIRef.__repr__^sC >V # #*GGn-G11CLL..1111rAcL|t||zSrDrr:rms r@__add__zURIRef.__add__f~~c$ii%/000rAcL||t|zSrDrrms r@__radd__zURIRef.__radd__is~~ec$ii/000rAcL|t||zSrDrrms r@__mod__zURIRef.__mod__lrrAr c`t|tr?t|}t|jt t dSt|tr3|}|tvr t|St}|t|<|Std|d)aCreate 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 NrHrz> is not a skolem URI) rM RDFLibGenidr(r pathlenrdflib_skolem_genidGenidr8r)rZ parsed_uribnode_idretvals r@ de_skolemizezURIRef.de_skolemizeos dK ( ( =!T),,Jzs3F/G/G/I/IJKKK K e $ $ =yH7""x(($*! ;;;;<< wyyII 'Ii77("9ooGG'GG''+l*EE !!#u---rArVrWr;c d|zS)Nz_:rUrYs r@r[zBNode.n3s d{rATuple[Type[BNode], Tuple[str]]c0tt|ffSrD)r r:rs r@rzBNode.__reduce__sD |$$rAc||jturd}n |jj}|dt|dS)Nzrdflib.term.BNoderr)rr r]r:rrs r@rzBNode.__repr__sC >U " ")GGn-G11CLL..1111rA authoritybasepathr c|t}|t}|t|z}tt ||S)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_AUTHORITYrr:r r')rZrrskolems r@ skolemizezBNode.skolemizesB  1I  *HCII%gi00111rA)rHrrrrr:rDr\)r;rrNN)rrrrr;r ) r]r^r_r`rarrfr[rrrrUrAr@r r s$I $AE!z|| #.#.#.#.#.J%%%%2222JN 2 2 2 2 2 2 2rAr ceZdZUdZded<ded<ded<ded <d Z d?d@dZdAdZedBdZ edCdZ edDdZ edEdZ dFdZ dGdZdHdZdId ZdId!ZdJd#ZdAd$ZdAd%ZdAd&ZdAd'ZdKd)ZdKd*ZdKd+ZdKd,ZdKd-ZdLd/ZdKd0ZdKd1ZdKd2ZdMdNd6Z dOdPd;Z!dQd<Z"dQd=Z#dCd>Z$d S)Rr a 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)rrrrNlexical_or_valuelangdatatype normalizec|dkrd}||n tj}||td|/t|s t dt |d|t |}d}d}t|tr-|p|j }|t||}n|j }|j }nt|t st|trt||}|I|tvr@t |}t|t"}|||} |p| }|(|r&t%||\} } | t'| r| }nP|}t%||\} } | dnt | } tj|| }| | }|d}t|tr|d}|t.t0fvrt3|}|t0fvrt5|} t ||} n,#t8$rt ||d} YnwxYw|| _|| _|| _|| _ | S)zCreate a new Literal instance.rNzmA Literal can only have one of lang or datatype, per http://www.w3.org/TR/rdf-concepts/#section-Graph-Literal'z' is not a valid language tag!rL)!rdflibNORMALIZE_LITERALS TypeErrorrG ValueErrorr:r rMr language_castLexicalToPythonrrHrN_toPythonMapping_check_well_formed_typesget_well_formed_by_value_castPythonToLiteralrSutil _coalescerK_XSD_NORMALISED_STRING _XSD_TOKEN_normalise_XSD_STRING_strip_and_collapse_whitespacerfrrrrr) rhrrrrrH ill_typeddt_urichecker well_formedrrinsts r@rfzLiteral.__new__s 2::D!*!6IIF> %:k/  Y $8$I$I! %*;F*C*C%'-$%E 45Ex P P FI ) 1vi7H7HI{,,XyAAH!#) # & . . @/66w??  . ; ; ;45EFF   } $ $=>NOO  ?;;s$455DD! ? ? ?;;s$4g>>DDD ?! # sH33&IIr;cV|j!t|j|j|jS|S)aw 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')) ``` N)rr)rHr rr rs r@rzLiteral.normalizes,* : !4: DMRRR RKrAc|jS)a 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@rzLiteral.ill_typeds rAc|jSrD)rrs r@rHz Literal.values {rAc|jSrD)rrs r@r zLiteral.language ~rAc|jSrD)rrs r@rzLiteral.datatyper"rADTuple[Type[Literal], Tuple[str, Union[str, None], Union[str, None]]]cHtt||j|jffSrD)r r:r rrs r@rzLiteral.__reduce__ s%  YY t} 5  rA(Tuple[None, Dict[str, Union[str, None]]]c<dt|j|jfS)N)r r)dictr rrs r@ __getstate__zLiteral.__getstate__sdDMDMJJJKKrAargTuple[Any, Dict[str, Any]]NonecD|\}}|d|_|d|_dS)Nr r)rr)rZr*_ds r@ __setstate__zLiteral.__setstate__s%1::rAvalc ||St|tst|}|jttfvrQ|jt vrC|}|}||z}t||jS|jtkr|jt vrw|}|}tj tddd||z}t| |jS|jtvr|jtvsH|jtvr|jtvs,|jt vrW|jt vs|j|jkr9tdt|jdt|j|j|jkrCt||z|j|jS|jt vr|jt vrtt#t%t#|t#|zddd d t(S t||}n4#t$r't|jt|z}YnwxYw|jt.vr|j} nt0} t||j| S) 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')) ``` Nrr+z!Cannot add a Literal of datatype z to a Literal of datatype f0.)rMr r _XSD_DATETIME _XSD_DATE_TIME_DELTA_TYPESr _XSD_TIMErcombinerr_ALL_DATE_AND_TIME_TYPESr r:r _NUMERIC_LITERAL_TYPESrroundrstrip _XSD_DECIMALrrH_STRING_LITERAL_TYPES _XSD_STRING) rZr1date1duration differenceselfvvalvsdts new_datatypes r@rzLiteral.__add__s0 ;K#w'' #,,C MmY7 7 7 111+/==??E36<<>>H)J: >>> >]i ' 'CL>> >  !999L(@@@ %===L$<<< !222\)::: 55uC 4E4Euuadeierasasuu  =CL ( ( #,,..0$-$-  M3 3 3 666WT]]__55 8O8OOQSTTXX__f&     /KKc** / / / OOc#hh. /} 555#}  + 1dmlCCC Cs K''.LLc ||St|tst|}t|dstdt|dstd|jt t fvrQ|jtvrC|}|}||z }t||jS|jtkr|jtvrw|}|}tj tddd||z }t| |jS|j|jkr|jtkrtj tj|}tj tj|}t||z tSt||z |j|jt t tfvrtn|jS|jt"vr|jt"vrtt%t't%|t%|z dd d d t*Std t-|jd t-|j)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')) ``` NrzCMinuend Literal must have Numeric, Date, Datetime or Time datatype.zFSubtrahend Literal must have Numeric, Date, Datetime or Time datatype.r3r4r+r5r6r7r8z&Cannot subtract a Literal of datatype z from a Literal of datatype )rMr rOr rr9r:r;rr<rr=rrtoday _XSD_DURATIONr r?rr@rArBr:) rZr1rErFrGrHrIrJvdts r@__sub__zLiteral.__sub__sT ;K#w'' #,,CtZ(( U j)) X  MmY7 7 7 111+/==??E36<<>>H)J: >>> >]i ' 'CL>> > =CL ( (} ))&tz||T]]__EE&tz||S\\^^DDsSy=AAAAMMOOcllnn4M =]Iy,QQQ& !]  M3 3 3 666WT]]__55 8O8OOQSTTXX__f&    |S\9J9J||hklplyhzhz|| rAr<c^|jt|jSt|dkS)zhDetermines the truth value of the Literal. Used for if statements, bool(literal), etc. Nr)rHr<rrs r@__bool__zLiteral.__bool__s, : ! ## #4yyA~rAct|jtttfr&t |jStd|)afImplements 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; )rMrHintr*floatr rr rs r@rzLiteral.__neg__sR0 dj3 5"9 : : 74:--//00 05T5566 6rAct|jtttfr&t |jStd|)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') ``` rU)rMrHrVr*rWr __pos__r rs r@rYzLiteral.__pos__sR. dj3 5"9 : : 74:--//00 05T5566 6rAct|jtttfr&t |jStd|)aImplements 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') ``` rU)rMrHrVr*rWr __abs__r rs r@r[zLiteral.__abs__:sR& dj3 5"9 : : 74:--//00 05T5566 6rAct|jtttfr&t |jStd|)aImplements 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') ``` rU)rMrHrVr*rWr rr rs r@rzLiteral.__invert__RsR& dj3 5"9 : : 74:002233 35T5566 6rAricN|dSt|tr|jtvr:|jtvr,|js%|js|j|j|j|jkSt j|jt}t j|jt}||krt j rtS||kS|j |j kr"|j sdS|j sdS|j |j kS|j|j}t|jtvrAtt|j}||j||jkS |j|jkS#t$rYnwxYwt!|t!|kr t!|t!|kS|j|jkr"|jdS|jdS|j|jkSdSt|t"rdStS)aJImplements 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 ``` NTdefaultF)rMr rr?rrHrrrrDDAWG_LITERAL_COLLATIONryr ru_TOTAL_ORDER_CASTERSr r:r)rZridtselfdtothercasters r@rzzLiteral.__gt__ks.` =4 eW % %< " M%;;;*@@@.A38?AZ+ 0GzEK//[**4=+*NNFk++ENK+PPG  0,))!G++}..}: 5:4=5>99z%%+*A ##';;;1$tz2B2BCF!6$*--u{0C0CCC: 33 D4yyCJJ&&4yy3u::--}..=( 5^+4=5>995 t $ $ "4! !s5F FFc|dSt|trD || o|| S#t$r t cYSwxYwt|t rdSt Sr|)rMr rzrnr ryrrms r@r}zLiteral.__lt__s =5 eW % % & &;;u---Ddggenn2DD & & &%%%% & eT " " 5s+AAAc||}|rdS ||S#t$r tcYSwxYw)a%Less 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)r}rnr ryrs r@rzLiteral.__le__s^ KK    4 "775>> ! " " "! ! ! ! "0AAc||}|rdS ||S#t$r tcYSwxYwr)rzrnr ryrs r@rzLiteral.__ge__s\ KK    4 "775>> ! " " "! ! ! ! "rgc~t|tr|j6|j/|jtvs|jtvr|j|jkrdSnj|jtkr|js|jtkr |jsdS|jpd|jpdkrdSdS)zVHelper method to decide which things are meaningful to rich-compare with this literal.NFrT)rMr r XSDToPythonrDr lowerrms r@_comparable_tozLiteral._comparable_tos eW % % !}(U^-GM44~[88}66$u 44U^4Nk11$-1 5M'R..00U^5Ir4P4P4R4RRR 5trArVct|}|jr)|t|jz}|j|t|jz}|S)anHash 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) )r:rrhashrkr)rZress r@rzLiteral.__hash__!s`>ll4   > 0 4,,..// /C > % 4'' 'C rAc&||urdS|dSt|trq|j|jko`|jr|jnd|jr|jndkot ||SdS)aEquality 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)rMr rrrkr:rlrms r@rlzLiteral.__eq__HsV 5==4 =5 eW % % %/1,/3~GT^))+++4/4HEO))+++DJ,JJtU++  urAc@t|tr*|jtvrz|jtvrl|jse|js^|jW|jP|j|j|j|jkSt ||rdStd|d||j pd |j pd krdStj |jt}tj |jt}|tkr&|tkrt ||S|tvrC|tvr:|jdur1|jdur(|j!|jt!|j|jS||kr-tjrtd|jd|jdS|j|j|j|jkSt ||rdS|jtkrdStd|d|t|t$rdSt|t r4|j dS|jtks|jt ||kSnt|t&t(t*fr|jtvr |j|kSnt|t,t.t0fr'|jt2t4t6fvr |j|kSnst|t8t:fr'|jt<t>t@fvr |j|kSn0t|tBr|jtDkr |j|kStFS) aCompare 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. NTzII cannot know that these two lexical forms do not map to the same value: z and rFr^z4I don't know how to compare literals with datatypes )$rMr rr?rrHr:rlr r rkrrrrD_XML_COMPARABLE_isEqualXMLNoder`rrVr*rWrrrr9r:r<rr,rO_XSD_DAYTIMEDURATION_XSD_YEARMONTHDURATIONr< _XSD_BOOLEANry)rZrirbrcs r@rnz Literal.eqs eW % %b + M%;;;*@@@.A38?AZ+ 0G:)ek.E:44zz$..$#t#:'+::27::  #**,,1E20L0L0N0NNNu[**4=+*NNFk++ENK+PPG$$K)?)?zz$...?**w//I/I.,,5?$3N3NZ+ 0G&tz5;???  0!#st}sschcqss!5 z%%+*AzU[00::dE** 4=K// 5 1"11).11 t $ $ +5 s # # +}(u} ++t}/D4yyE))0EY6 7 7 +} 666zU**7 h5 6 6 +} 9 EEEzU**F  84 5 5 +}$&! zU** t $ $ +} ,,zU**rAc.|| SrD)rnrms r@rrz Literal.neqs775>>!!rArVrWr:cd|r||jS|S)aReturns 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_n3rrYs r@r[z Literal.n3s:F  &##3D3Q#RR R##%% %rAF use_plainry+Optional[Callable[[URIRef], Optional[str]]]c(|r|jtvr |j|jtvru t |}t j|st j|r|d|Sn&#t$r|d|cYSwxYw|jtkr tddt |dS|jtkr|}d|vr d|vr d|vr|dz }|S|jtkr|S|S|}|j}d}||r ||}|sd|d }|tvr t |}t j|r*|d d d d }t j|r|d d}n'#t$rt#jd|YnwxYw|j}|r|d|S|r|d|S|S)a{Internal 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*eer8Ez.0rrinfINFInfinitynanNaNzSerializing weird numerical @z^^)r_PLAIN_LITERAL_TYPESrH_NUMERIC_INF_NAN_LITERAL_TYPESrWmathisinfisnanrzr  _XSD_DOUBLErrBrvrk _quote_encodereplacewarningswarnr ) rZr{ryvrKencodedr quoted_dtr s r@rzzLiteral._literal_n3Cs|  %*>>>z%=$BBBG!$KK:a==KDJqMMK#'#3#3E>#J#JJK%GGG#//~FFFFFG =K//y#%++/A/ABBB]l22 A!||1 AT H]l22"9??,,,"9$))++=   5*N844  ,+OOO 999 Kd Az!}}#*//%"?"?"G"G&##z!}}@")//%"?"?!KKKM"I"I"IJJJJJK =  **** *  ,,,, ,Ns%A A88 BBA7G!G65G6cd|vrq|dd}d|vr|dd}|ddkr|ddkr|dddzdz}d |d d zSd |dd ddddd d zS)N \z\\z"""z\"\"\"rz"""%s""" z\rz"%s"z\nz\")r)rZrs r@rzLiteral._quote_encodes 4<<ll400G}}!//%==r{c!!gbkT&9&9!#2#,-3e < << <DLLu55==dFKKSSUgdE""# #rAcpt|g}|j*|dt |jz|j*|dt |jz|jtkrd}n |jj}|dd |dS)Nzlang=z datatype=zrdflib.term.Literalrz, r) r:rr appendreprrrr r]join)rZargsrs r@rzLiteral.__repr__s T""# = $ KK$t}"5"55 6 6 6 = $ KK d4=&9&99 : : : >W $ $+GGn-G..DIIdOO....rAc"|j|jS|S)zV Returns an appropriate python datatype derived from this RDF Literal rrs r@rzLiteral.toPythons : !:  rA)NNN)rrrrrrrr)r;r )r;r)r;r)r;r)r;r)r;r$)r;r&)r*r+r;r,)r1rr;r )r;r<r)r;rVrDr\)FN)r{r<ryr|r;r:r)%r]r^r_r`rrarfrrrrHr rrr)r0rrQrSrrYr[rrzr}rrrlrrlrnrrr[rzrrrrUrAr@r r s1jjXKKKBI #"&$( VVVVVp4   X XXX    LLLL'''' iDiDiDiDVoooob7777:777787777077772n"n"n"n"`    """"$""""<%%%%N8888tttttl""""F&F&F&F&F&T FJxxxxxt####6 / / / /rAr xmlstringxml.dom.minidom.Documentc~tjjd|d}||S)Nzz)xmldomminidom parseStringr)rrs r@ _parseXMLrsB W_ ( (E)EEEF  MrA lexical_form xml.dom.minidom.DocumentFragmentc8tjtjdd} ||}n;#tjj$r$}td||d}~wwxYw| |S)ai 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 ParseErrorrinfor)rparserresultr~s r@ _parse_htmlrs  " 1 1% 8 8F393G3G 3U3U   * 0Q00111  MsA BA>>BrNc2tj|d}|S)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)rHrs r@ _write_htmlrs E 2 2 2F MrAxmlnodeAUnion[xml.dom.minidom.Document, xml.dom.minidom.DocumentFragment]cxt|tjjjr:tjj}|xj|jz c_|}|d}|dr |dd}|dr |dd}|dkrd}|S) NrLs&&sisrA) rMrrrDocumentFragmentDocument childNodestoxmlr)rr/rKs r@ _writeXMLrs'37?;<< GO $ $ & & **  gA ||=>> bccF||.// bfI '''  HrAUnion[str, bytes, Literal]crt|tr|}t|SrD)rMr:encoderrs r@ _unhexlifyr3s/%  U  rAcgd}gd}|}||vrdS||vrtjd|dtdS) 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)r7false0falseTzParsing weird boolean, z does not map to True or False)categoryF)rkrr UserWarning)rHtrue_accepted_valuesfalse_accepted_values new_values r@ _parseBooleanr:sw 877::: I(((t--- Me M M M      5rAlexicalrc |duS)aN 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. NrUrrHs r@rrMs  rAc^t|dkot|to|dkS)zG xsd:unsignedInteger and xsd:unsignedLong must not be negative r)rrMr*rs r@_well_formed_unsignedlongrYs- w<cP|jduo|j|du|fSrDtzinfo utcoffsetrs r@rs0 D NU\%;%;E%B%B$%N rAcP|jduo|jddu|fSrDrrs r@rr s0 D MU\%;%;D%A%A%M rAc*|SrD)rrs r@rrsEKKMMrAz%Dict[Type[Any], Callable[[Any], Any]]rarC_StrT)boundobjpTypecastFuncOptional[Callable[[Any], Any]]dTypeOptional[_StrT]Tuple[Any, Optional[_StrT]]c4| |||fS|||fS|dfSrDrU)rrr r"s r@ _py2literalr&s7 x}}e##  EzDyrArrTuple[Any, Optional[str]]ctD]2\\}}}t||r||krt||||cS3tD],\}\}}t||rt||||cS-|dfS)z 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)_SpecificPythonToXSDRulesrMr&_GenericPythonToXSDRules)rrrr"r s r@rr+s%><<  c5 ! ! value space binding for `Literal`.N) rclearupdaterjr*extend _OriginalGenericPythonToXSDRulesr)!_OriginalSpecificPythonToXSDRulesrUrAr@_reset_bindingsrGs|K(((""$$$##$DEEE##%%%$$%FGGGGGrArc$ t|}n#t$rYdSwxYw|? ||S#t$r&td|d|dYdSwxYw t |S#t $rt |dcYSwxYw)zMap 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_inforL)rKeyErrorrrrr:r)rr conv_funcs r@r r s$X. tt  9W%% %    NNnXnnclnn     44   )w<< ! ) ) )w(( ( ( (  )s-   /,AA#A22BB_AnyTrct|tr>|ddddddS|S)zxReplaces \t, \n, \r (#x9 (tab), #xA (linefeed), and #xD (carriage return)) with space without any whitespace collapsing.  rr)rMr:rrs r@rrsU"C((Y ''c22::4EEMMdTWXXX rAct|tr(tjdd|S|S)Nz +rO)rMr:rerstriprPs r@rrs>"C((;vdC!1!7!7!9!9::: rA pythontype Type[Any] constructorOptional[Callable[[str], Any]] lexicalizer,Optional[Callable[[Any], Union[str, bytes]]]datatype_specificc|r|td|tvrtd|d||}|t|<|r t||f|fdSt |||ffdS)a6 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.)rrrrr)rr*)rrTrVrXrZs r@rrs(MX-KLLL###MHMMMNNN !,XO!((:x*@+)NOOOOO ''k85L(MNNNNNrAc@eZdZdZdZddZddZddZddd ZddZ d S)r zo A Variable - this is used for querying, or in Formula aware graphs, where Variables can be stored rUrHr:ct|dkrtd|ddkr |dd}t||S)Nrz7Attempted to create variable with empty string as name!?r+)rrr:rfrgs r@rfzVariable.__new__) sN u::??UVV V 8s??!""IE{{3&&&rAr;c||jturd}n |jj}|dt|dS)Nzrdflib.term.Variablerr)rr r]r:rrs r@rzVariable.__repr__0 sC >X % %,GGn-G11CLL..1111rAc d|zSNr^rUrs r@rzVariable.toPython8 TzrANrVrWc d|zSrarUrYs r@r[z Variable.n3; rbrA!Tuple[Type[Variable], Tuple[str]]c0tt|ffSrD)r r:rs r@rzVariable.__reduce__> s3t99,''rArrrDr\)r;rd) r]r^r_r`rarfrrr[rrUrAr@r r ! s I''''2222((((((rAr zDict[Type[Node], int]rx (nodeUnion[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]ricddlm}fd}dSjjkrdSj|j|jfvr |Sj|jkr9t rLttj j j sJttj j j sJj j krj j ksdSdjD}djD}t!|t!|krdS|D]O}||vrF|d|d|d|dksdSP|Sj|j|j|j|jfvrt rttj j jtj j jtj j jtj j jfsJttj j jtj j jtj j jtj j jfsJjjkSj|jkrst rLttj j jsJttj j jsJjjkojjkSj|jkrjjkSj|j krst rLttj j j!sJttj j j!sJj"j"koj#j#kStIdj) Nr)rctjtjkrdStdjjD]\}}t||sdSdS)NFc ||fSrDrU)xys r@rz2_isEqualXMLNode..recurse..t s 1vrAT)rrmaprs)ncocrjris r@recursez _isEqualXMLNode..recursej sw t  3u'7#8#8 8 85--t@PQQ  FB"2r** uu trAFc*g|]}|ddk|Srzhttp://www.w3.org/2000/xmlns/rU.0ks r@ z#_isEqualXMLNode.. 2   t666 666rAc*g|]}|ddk|SrvrUrws r@rzz#_isEqualXMLNode.. r{rAr+z*I dont know how to compare XML Node type: )%xml.dom.minidomrnodeType DOCUMENT_NODEDOCUMENT_FRAGMENT_NODE ELEMENT_NODErrMrrrElementtagName namespaceURI attributeskeysNSrgetAttributeNS TEXT_NODE COMMENT_NODECDATA_SECTION_NODE NOTATION_NODETextComment CDATASectionNotationdataPROCESSING_INSTRUCTION_NODEProcessingInstructiontarget ENTITY_NODE nodeValueDOCUMENT_TYPE_NODE DocumentTypepublicIdsystemIdr)rjriXMLNodertn_keyso_keysrys`` r@rsrsJ s<0/////  |u}u }&&u }.0NOOOwyy '. . .  >dCGO$;<< < <<eSW_%<== = == LEM ) )d.?5CU.U.U5   _++--      %,,..    v;;#f++ % %5  AV ''!ad33u7K7KAaDRSTURV7W7WWWuuX wyy "     GO(GO+GO0GO,   GO(GO+GO0GO,   yEJ&& '= = =  LdCGO$IJJ J JJeSW_%JKK K KKyEJ&F4;%,+FF '- - -~00 '4 4 4  CdCGO$@AA A AAeSW_%ABB B BB}.R4=EN3RRTT]TTUUUrA)r9r:r;r<)rBr:r;r<)rHrIr;r<r)rr:r;r)rr:r;r)rHrr;rN)rrr;rN)rHrr;rN)rrIrHrr;r<) rrrrr r!r"r#r;r$)rrrrr;r')r;r,)rrIrrr;r)rrLr;rL)NNF) rr:rTrUrVrWrXrYrZr<r;r,)rjrkrirkr;r<)r` __future__rrbrR fractionsr__all__loggingrrr}rbase64rrbinasciirr collectionsrrrrrrrrrtypesrtypingrrrrrr 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>rrErGrSABCrr:r rr rrrr r rrrrrrrrrrrrrrrrrrr_XSD_PFX_RDF_PFX_RDF_XMLLITERAL_RDF_HTMLLITERALrDrr _XSD_FLOATrrB _XSD_INTEGERrvr9r:r<rOrtru _OWL_RATIONAL_XSD_B64BINARY_XSD_HEXBINARY _XSD_GYEAR_XSD_GYEARMONTHr?rrrr;r>rrrrarCrr&rrWr<rVr*rrlistrErNr)rFrjrrrrrCrGr rLrrrr rxrsrUrAr@rs{,#"""""     ''''''''''''''''######444444444444                          6555555555 ######Q++++++PPPPPPPPPPPPPP OOOMMHHH7  8 $ $$ 2#'9::,,,,$SSSSS37SSScccccscccLZ&y=y=y=y=y=^y=y=y=x     F   %(    U2U2U2U2U2NU2U2U2p^^^^^j^^^B'4        (&    LLLLQQQQ    VVVVVVVVQQQQRRRROOOO1111000011110000 / 8&L0116(V+,,fX()) += =>> VHw& ' ' VHw& ' ' fX()) vh*++ vh*++ vh*++ x*,-- F8f$ % % F8f$ % % x*,-- vh)::;;+> >???@@ >122;.// VHw& ' ' &L011 F8g  F8f  F8e  F8f  F8' '(( F8* *++ F8* *++ F8' '(( F8g  F8n $%% F8m #$$ F8n $%% F8o %&&!.* , F8g 6  ,) 0DFW/WWWWW       GO99 ?      F8( ()) F8g  - s###    B , T;   $ $l 344 |$% !!<01 ''78 # #Y /0 # #Y /0 //?@002FGHW_ ?;< m$%$ ##  )K9I+JK$(4(@#A#A  J@@A OHHI >G$ ^g& >I& ^i(     %)D)B$C$C!!D$!D F8f z!D F8f ~!D F8j !!> !D  F8j !!#5 !D  F8' '((*< !D F8) )**,>!D F8k !""J!D F8h !D F8( ())4!D F8g !D F8j !!4!D F8i   -!D F8i   '!D F8i   )!D  F8* *++Y!!D" F8f y#!D$ F8* *++Y F8' '(() F8e c F8n $%%y F8' '(() F8g  F8m #$$c F8f s F8o %&& F8n $%%s F8g  F8h  F8n $%%y F8h YA!D!D !!!!F %0K !+: F8n $%%'@ F8o %&&(B F8n $%%'@ T    IKJJJJ $$$ H H H H%)%)%)%)P s###37@D# O O O O OF(((((z(((J$/;s#3#3 3333 %Xr62wCDDDKVKVKVKVKVKVsC CC