i\UdZddlmZddlZddlZddlmZgdZddlZddl 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;mm?Z?ddl@mAZAmBZBmCZCmDZDmEZEdZF ddlGZGdZFdZIejeKZLdZMdZNiZOdePd<dZQddZRedZSddZTdd ZUGd!d"ejZWGd#d$eWeXZYGd%d&eYZZGd'd(eZZ[Gd)d*e[Z\Gd+d,e\Z]dd-Z^Gd.d/eZZ_Gd0d1eYZ`dd2Zadd3Zbdd4Zc dd5Zddd6Zedd7Zfdd8Zgdd9Zhdd:Zidd;Zjdd<Zkdd=Zldd>Zmdd?Zndd@ZoddAZpddBZqddCZrddDZsdEZtdFZue[eudGzZve[eudHzZwe[etdIzZxe[etdJzZye[etdKzZze[etdLzZ{e[etdMzZ|e[etdNzZ}e[etdOzZ~e[etdPzZe[etdQzZe[etdRzZe[etdSzZe[etdTzZe[etdUzZe[etdVzZe[dWZe[etdXzZe[etdYzZe[etdZzZe[etd[zZe~e}e|e[etdLze[etd\ze[etd]ze[etd^ze[etd_ze[etd`ze[etdaze[etdbze[etdcze[etddze[etdeze[etdfze[etdgzfZdhePdi<e~ee|e}efZdhePdj<e[etdLze|e}fZdhePdk<eeefZdhePdl<eefZdhePdm<eezZdhePdn<edoedpe j"j$j&dqiZdrePds<exevewe[etdJze[etdKzfZdhePdt<e)dueXvZ ddwZ ddxZeXdyfede|ffedzeffede~ffe4de~ffed{e}ffed|effed}effed~effe6deffedeffe j"j$j&edevffedeffg ZdePd<eG7ej;e j"j$j<ecewffeeZeefdfeefdfeXefefeefefeXefefeefefgZdePd<eeZidde[etdSze9e[etdRze:e[etdZze<e[etd[ze=e[etdQze8e[etdTze;e[etdUze;e[etdVze;e[etdYzeee[etdIzde[etdJzde[etdKzde[etdzde[etdPzefe[etdNzee[etdOze4ie[etdaze4e[etd^ze4e[etd`ze4e[etd_ze4e[etd]zee[etdfze4e[etdbze4e[etdczee[etdezee[etd\zee[etdgzee[etddzee[etdLzee[etdMzee[etdXzee[etdzdeveaZdePd<eGebeew<evewfZdhePd<nevfZe[etdPzeie[etdazere[etd`zepe[etd_zese[etdbzeqe[etd]zeje[etdczele[etd\zene[etdezeke[etdfzehe[etdgzeme[etddzeoi ZdePd<iZdePd<ejQeddZ ddZe)de!vZddZddZ d ddZGddeYZeeZdePd<ejQe_dede[de`di ddZy#eH$rdZGYwxYw)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: * :class:`Blank Nodes ` * :class:`URI References ` * :class:`Literals ` (which consist of a literal value,datatype and language tag) Those that extend the RDF model into N3: * :class:`Formulae ` * :class:`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_durationparse_xsd_gyearparse_xsd_gyearmonth)NamespaceManager)AlternativePathInvPath NegatedPathPath SequencePathFTzhttps://rdflib.github.ioz/.well-known/genid/z/.well-known/genid/rdflib/zDict[str, BNode]skolemsz <>" {}|\^`c&tD]}||vsyy)NFT)_invalid_uri_chars)urics :C:\Projects\mas-dev\.venv\Lib\site-packages\rdflib/term.pyrrks  8  z^[a-zA-Z]+(?:-[a-zA-Z0-9]+)*$c>ttj|SN)bool_lang_tag_regexmatch)tags r?_is_valid_langtagrGus %%c* ++r@ct|trt|dd}}nt|}} ||y#t$rYywxYw)z[ Verify that the provided value can be converted into a Python unicode object. decodeutf-8FT) isinstancebytesgetattrstr UnicodeError)value coding_funcparams r?_is_valid_unicoderSysM %$UH5wU  %U E  s 2 >>c<eZdZdZdZej dddZy)rz A Node in the Graph. NcyrBrUselfnamespace_managers r?n3zNode.n3sORr@rBrYzOptional[NamespaceManager]returnrN)__name__ __module__ __qualname____doc__ __slots__abcabstractmethodrZrUr@r?rrs"IRRr@rc~eZdZdZdZddZddZddZddZddZ ddZ dd Z dd Z dd Z ddd Zej Zy )r zg See http://www.w3.org/2002/07/rdf-identifer-terminology/ regarding choice of terminology. rUc.tj||SrB)rN__new__clsrPs r?rfzIdentifier.__new__s{{3&&r@c$|j|S)zNA "semantic"/interpreted equality function, by default, same as __eq____eq__rXothers r?eqz Identifier.eq{{5!!r@c$|j|S)zOA "semantic"/interpreted not equal function, by default, same as __ne__)__ne__rls r?neqzIdentifier.neqror@c&|j| SrBrjrls r?rqzIdentifier.__ne__s;;u%%%r@c^t|t|urt|t|k(Sy)a Equality for Nodes. >>> 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)typerNrls r?rkzIdentifier.__eq__s*( :e $t9E * *r@c|yt|t|urt|t|kDSt|tr%tt|tt|kDSt 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 TrurNrKr _ORDERINGNotImplementedrls r?__gt__zIdentifier.__gt__s\ = $Z4; &t9s5z) ) t $T$Z(9T%[+AA Ar@c|yt|t|urt|t|kSt|tr%tt|tt|kSt SNFrwrls r?__lt__zIdentifier.__lt__sZ = $Z4; &t9s5z) ) t $T$Z(9T%[+AA Ar@c4|j|}|ry||k(SNT)r}rXrmrs r?__le__zIdentifier.__le__ KK  u}r@c4|j|}|ry||k(Sr)rzrs r?__ge__zIdentifier.__ge__rr@cHt|jt|SrB)rN startswith)rXprefixstartends r?rzIdentifier.startswiths4y##CK00r@N)rPrNr\r rmrr\rC)..)rrNr\rC)r]r^r_r`rarfrnrrrqrkrzr}rrrrN__hash__rUr@r?r r sK I'" " &2( 1||Hr@r c.eZdZdZdZddZdd dZd dZy) 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 rUct|fSrBrNrXs r?__getnewargs__zIdentifiedNode.__getnewargs__sD |r@NctrB)NotImplementedErrorrWs r?rZzIdentifiedNode.n3 s !##r@ct|SrBrrs r?toPythonzIdentifiedNode.toPython s 4yr@)r\z Tuple[str]rBr[r\rN)r]r^r_r`rarrZrrUr@r?rrs I$r@rceZdZUdZdZded<ded<ded<d ed <ddd Zddd ZddZe ddZ ddZ ddZ ddZ ddZddZddZy )r a RDF 1.1's IRI Section https://www.w3.org/TR/rdf11-concepts/#section-IRIs .. note:: 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 `_ 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__Nc:|7|jd}t||d}|r|jds|dz }t|stj |d t j ||}|S#t$rt j ||d}Y|SwxYw)N#r+)allow_fragmentszE does not look like a valid URI, trying to serialize this will break.rJ)endswithr'rloggerwarningrNrfUnicodeDecodeError)rhrPbase ends_in_hashrts r?rfzURIRef.__new__%s   >>#.LD%;E~~c*SLEU# NN'^_  2S%(B " 2S%1B  2sA66 BBcht|std|d|r|j|Sd|dS)a This will do a limited check for valid URIs, essentially just making sure that the string includes no illegal characters (``<, >, ", {, }, |, \, `, ^``) :param 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 normalizeUrirWs r?rZz URIRef.n3:sPT"D6EF  $11$7 7tfA; r@c@d|vrt|\}}t|S|S)Nr)r&r )rXurlfrags r?defragz URIRef.defragNs% $;!$IC#; Kr@c,t|jS)z Return the URL Fragment >>> URIRef("http://example.com/some/path/#some-fragment").fragment 'some-fragment' >>> URIRef("http://example.com/some/path/").fragment '' )r(fragmentrs r?rzURIRef.fragmentUs~&&&r@c&tt|ffSrB)r rNrs r? __reduce__zURIRef.__reduce__asT %%r@c|jturd}n|jj}|dtj |dS)Nzrdflib.term.URIRef()) __class__r r]rN__repr__rXclsNames r?rzURIRef.__repr__ds? >>V #*Gnn--G!CLL./q11r@c<|jt||zSrBrrNrls r?__add__zURIRef.__add__l~~c$i%/00r@c<|j|t|zSrBrrls r?__radd__zURIRef.__radd__os~~ec$i/00r@c<|jt||zSrBrrls r?__mod__zURIRef.__mod__rrr@ct|tr2t|}t|jt t dSt|tr)|}|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. .. versionadded:: 4.0 NrPrz> is not a skolem URI) rK RDFLibGenidr(r pathlenrdflib_skolem_genidGenidr:r)rX parsed_uribnode_idretvals r? de_skolemizezURIRef.de_skolemizeus dK (!TF,Jzs3F/G/IJK K e $H7"x(($*! av%:;< yI 'Ii7"9oG'G'++ *E !!#u--r@c d|zS)Nz_:rUrWs r?rZzBNode.n3s d{r@c&tt|ffSrB)r rNrs r?rzBNode.__reduce__sD |$$r@c|jturd}n|jj}|dtj |dS)Nzrdflib.term.BNoderr)rr r]rNrrs r?rzBNode.__repr__s? >>U ")Gnn--G!CLL./q11r@ch|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 .. versionadded:: 4.0 )_SKOLEM_DEFAULT_AUTHORITYrrNr r')rX authoritybasepathskolems r? skolemizezBNode.skolemizes:  1I  *HCI%gi011r@)rPrrz-Optional[Union[Callable[[], str], Generator]]rrNr\r rBr[)r\zTuple[Type[BNode], Tuple[str]]rNN)rrrrr\r ) r]r^r_r`rarrfrZrrrrUr@r?r r sz$I $AE!| #.#.?#. #.  #.J%2JN 2& 29F 2  2r@r ceZdZUdZded<ded<ded<ded <d Z d* d+d Zd,d Zed-dZ ed.dZ ed/dZ ed0dZ d1dZ d2dZd3dZd4dZd4dZd5dZd,dZd,dZd,dZd,dZd6dZd6dZd6dZd6dZd6d Zd7d!Zd6d"Zd6d#Zd6d$Zd8d9d%Z d: d;d&Z!d`_. 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.: >>> from rdflib.namespace import XSD >>> Literal('01') != Literal('1') # clear - strings differ True but with data-type they get normalized: >>> Literal('01', datatype=XSD.integer) != Literal('1', datatype=XSD.integer) False unless disabled: >>> Literal('01', datatype=XSD.integer, normalize=False) != Literal('1', datatype=XSD.integer) True Value based comparison is possible: >>> Literal('01', datatype=XSD.integer).eq(Literal('1', datatype=XSD.float)) True The eq method also provides limited support for basic python types: >>> 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. >>> 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): >>> Literal(1).__gt__(2.0) NotImplemented r_valuer _languageOptional[URIRef] _datatypeOptional[bool] _ill_typed)rrrrNcP|dk(rd}||ntj}| | td|#t|st dt |d| t |}d}d}t|tr8|xs |j}| t||}n|j}|j}nt|t st|trnt||}|=|tvr5t |}tj!|t"}|||} |xs| }|i|rgt%||\} } | Vt'| rK| }nH|}t%||\} } | dn t | } tj(j+|| }| | }|d}t|tr|j-d}|t.t0fvr t3|}|t0fvr t5|} t j7||} || _|| _|| _|| _ | S#t8$rt j7||d} Y@wxYw)NrzmA 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!rJ)!rdflibNORMALIZE_LITERALS TypeErrorrG ValueErrorrNr rKr language_castLexicalToPythondatatyperPrL_toPythonMapping_check_well_formed_typesget_well_formed_by_value_castPythonToLiteralrSutil _coalescerI_XSD_NORMALISED_STRING _XSD_TOKEN_normalise_XSD_STRING_strip_and_collapse_whitespacerfrrrrr) rhlexical_or_valuelangr normalizerP ill_typeddt_urichecker well_formedrrinsts r?rfzLiteral.__new__vsa 2:D!*!6IF %:k/  Y$8$I! %*;F*C'-$%E 45Ex P FI ) 1vi7HI{{,,XyAH!#) # & ./66w?  . ; ;45EF   } $=>NO  ?KK-=>D! # " ?;;s$4g>D ?sH H%$H%cv|j,t|j|j|jS|S)a8 Returns a new literal with a normalised lexical representation of this literal >>> 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 >>> Literal("a", datatype=XSD.integer, normalize=False) rdflib.term.Literal('a', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) )rr)rPr rrrs r?rzLiteral.normalizes. :: !4:: DMMR RKr@c|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_typedsr@c|jSrB)rrs r?rPz Literal.values {{r@c|jSrB)rrs r?rzLiteral.language ~~r@c|jSrB)rrs r?rzLiteral.datatyperr@cRtt||j|jffSrB)r rNrrrs r?rzLiteral.__reduce__s'  Y t}} 5  r@cHdt|j|jfS)N)rr)dictrrrs r? __getstate__zLiteral.__getstate__sdDMMDMMJKKr@c6|\}}|d|_|d|_y)Nrr)rr)rXarg_ds r? __setstate__zLiteral.__setstate__s!1::r@c ||St|ts t|}|jttfvrN|jt vr<|j }|j }||z}t||jS|jtk(r{|jt vri|j }|j }tjtddd||z}t|j|jS|jtvr|jtvsa|jtvr|jtvs=|jt vrb|jt vs|j|jk7r7tdt|jdt|j|j|jk(rAt|j |j z|j|jS|jt vr|jt vrutt#t%t#|j t#|j zddj'dj'd t(S tj+||}|jt.vr |j} nt0} t||j| S#t$r$t|j,t|z}YiwxYw) a >>> 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')) rr+z!Cannot add a Literal of datatype z to a Literal of datatype f0.)rKr r _XSD_DATETIME _XSD_DATE_TIME_DELTA_TYPESr _XSD_TIMErcombinerr_ALL_DATE_AND_TIME_TYPESrrNr_NUMERIC_LITERAL_TYPESrroundrstrip _XSD_DECIMALrrP_STRING_LITERAL_TYPES _XSD_STRING) rXvaldate1duration differenceselfvvalvsdts new_datatypes r?rzLiteral.__add__ s* ;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&   /KKc* }} 55#}}  + 1dmmlC C / Oc#h. /sL*MMc N||St|ts t|}t|ds tdt|ds td|jt t fvrN|jtvr<|j}|j}||z }t||jS|jtk(r{|jtvri|j}|j}tjtddd||z }t|j|jS|j|jk(r|jtk(rtjtj|j}tjtj|j}t||z tSt|j|jz |j |jt t tfvr tS|jS|jt"vr|jt"vrutt%t't%|jt%|jz ddj)d j)d t*Std t-|jd t-|j) aQ >>> from rdflib.namespace import XSD >>> 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')) >>> Literal("1.1") - 1.0 # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... 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')) >>> from rdflib.namespace import XSD >>> 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')) rzCMinuend Literal must have Numeric, Date, Datetime or Time datatype.zFSubtrahend Literal must have Numeric, Date, Datetime or Time datatype.r)r*r+r+r,r-r.z&Cannot subtract a Literal of datatype z from a Literal of datatype )rKr rMrrr/r0r1rr2rr3rrtoday _XSD_DURATIONrr5rr6r7r8rN) rXr;r<r=r>r?r@rAvdts r?__sub__zLiteral.__sub__qsB ;K#w'#,CtZ(U j)X  MMmY7 7 11+/==?E36<<>H)J: > >]]i 'CLL > ==CLL (}} )&&tzz|T]]_E&&tzz|S\\^DsSy=AAMMOclln4MM ==]Iy,QQ&  "]]  MM3 3 66WT]]_5 8OOQSTUVW__f&  8S\\9J8KKghklplylyhzg{| r@c`|jt|jSt|dk7S)zc Is the Literal "True" This is used for if statements, bool(literal), etc. r)rPrCrrs r?__bool__zLiteral.__bool__s+ :: ! # #4yA~r@ct|jtttfr#t |jj Std|)a >>> (- Literal(1)) rdflib.term.Literal('-1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) >>> (- Literal(10.5)) rdflib.term.Literal('-10.5', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#double')) >>> 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')) >>> (- Literal("1")) Traceback (most recent call last): File "", line 1, in TypeError: Not a number; rdflib.term.Literal('1') >>> Not a number; )rKrPintr*floatr rrrs r?rzLiteral.__neg__sC" djj3 5"9 :4::--/0 0nTH56 6r@ct|jtttfr#t |jj Std|)a >>> (+ Literal(1)) rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) >>> (+ Literal(-1)) rdflib.term.Literal('-1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) >>> 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')) >>> (+ Literal("1")) Traceback (most recent call last): File "", line 1, in TypeError: Not a number; rdflib.term.Literal('1') rL)rKrPrMr*rNr __pos__rrs r?rPzLiteral.__pos__sC djj3 5"9 :4::--/0 0nTH56 6r@ct|jtttfr#t |jj Std|)a >>> abs(Literal(-1)) rdflib.term.Literal('1', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) >>> 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')) >>> abs(Literal("1")) Traceback (most recent call last): File "", line 1, in TypeError: Not a number; rdflib.term.Literal('1') rL)rKrPrMr*rNr __abs__rrs r?rRzLiteral.__abs__ sC djj3 5"9 :4::--/0 0nTH56 6r@ct|jtttfr#t |jj Std|)a  >>> ~(Literal(-1)) rdflib.term.Literal('0', datatype=rdflib.term.URIRef('http://www.w3.org/2001/XMLSchema#integer')) >>> 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')) Not working: >>> ~(Literal("1")) Traceback (most recent call last): File "", line 1, in TypeError: Not a number; rdflib.term.Literal('1') rL)rKrPrMr*rNr rrrs r?rzLiteral.__invert__sC djj3 5"9 :4::0023 3nTH56 6r@c|yt|tr@|jtvr[|jtvrI|js=|js1|j %|j |j |j kDSt jj|jt}t jj|jt}||k7rt jrtS||kDS|j|jk7r3|jsy|jsy|j|jkDS|j |j vt|j tvrAtt|j }||j ||j kDS |j |j kDSt!|t!|k7rt!|t!|kDS|j|jk7r3|jy|jy|j|jkDSyt|t"rytS#t$rYwxYw)a- This implements ordering for Literals, the other comparison methods delegate here This tries to implement this: http://www.w3.org/TR/sparql11-query/#modOrderBy In short, Literals with compatible data-types are ordered in value space, i.e. >>> from rdflib import XSD >>> Literal(1) > Literal(2) # int/int False >>> Literal(2.0) > Literal(1) # double/int True >>> from decimal import Decimal >>> Literal(Decimal("3.3")) > Literal(2.0) # decimal/double True >>> Literal(Decimal("3.3")) < Literal(4.0) # decimal/double True >>> Literal('b') > Literal('a') # plain lit/plain lit True >>> Literal('b') > Literal('a', datatype=XSD.string) # plain lit/xsd:str True Incompatible datatype mismatches ordered by DT >>> Literal(1) > Literal("2") # int>string False Langtagged literals by lang tag >>> Literal("a", lang="en") > Literal("a", lang="fr") False TdefaultF)rKr rr5rrPrr r r:DAWG_LITERAL_COLLATIONryrru_TOTAL_ORDER_CASTERSrrNr)rXrmdtselfdtothercasters r?rzzLiteral.__gt__5sH = eW % MM%;;*@@..5??ZZ+ 0GzzEKK//[[**4==+*NFkk++ENNK+PG 00))!G++}}.}} ==5>>99zz%%++*A #';;1$tzz2BCF!$**-u{{0CCC:: 334yCJ&4y3u:--}}.==( ^^+==5>>99 t $! !+!sI,, I87I8c|yt|tr' |j| xr|j| St|t ryt S#t$r t cYSwxYwr|)rKr rzrnrryrrls r?r}zLiteral.__lt__sg = eW % &;;u--Ddggen2DD eT "  &%% &s%AA$#A$cx|j|}|ry |j|S#t$r tcYSwxYw)z >>> 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}rnrryrs r?rzLiteral.__le__s@ KK   "775> ! "! ! " '99cx|j|}|ry |j|S#t$r tcYSwxYwr)rzrnrryrs r?rzLiteral.__ge__s> KK   "775> ! "! ! "r^ct|tr|jK|j?|jtvs|jtvr|j|jk7ryy|jtk(r+|js|jtk(r |jsy|j xsdj |j xsdj k7ryy)zo Helper method to decide which things are meaningful to rich-compare with this literal FrT)rKr r XSDToPythonr:rlowerrls r?_comparable_tozLiteral._comparable_tos eW %}}(U^^-GMM4~~[8}}6$ 4U^^NNk1$-- MM'R..0U^^5Ir4P4P4RR r@ctj|}|jr&|t|jj z}|j |t|j z}|S)a >>> from rdflib.namespace import XSD >>> a = {Literal('1', datatype=XSD.integer):'one'} >>> Literal('1', datatype=XSD.double) in a False "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) )rNrrhashrbr)rXress r?rzLiteral.__hash__sW<ll4  >> 4,,./ /C >> % 4' 'C r@c<||ury|yt|tr|j|jk(xri|jr|jj nd|jr|jj ndk(xrt j ||Sy)a Literals are only equal to other literals. "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) >>> 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)rKr rrrbrNrkrls r?rkzLiteral.__eq__sH 5= = eW %%//1,/3~~T^^))+4/4EOO))+DJ,JJtU+  r@ct|tr}|jtvr|jtvr|js}|jsq|j e|j Y|j %|j |j |j k(St j||rytd|d||jxsdj|jxsdjk7rytjj|jt}tjj|jt}|tk(r|tk(rt j||S|tvr\|tvrT|jdurF|jdur8|j ,|j t!|j |j S||k7r6tj"r%td|jd|jy|j %|j |j |j k(St j||ry|jtk(rytd|d|t|t$ryt|t r@|jy|jtk(s |jt ||k(StFSt|t&t(t*fr'|jtvr|j |k(StFSt|t,t.t0fr2|jt2t4t6fvr|j |k(StFSt|t8t:fr2|jt<t>t@fvr|j |k(StFSt|tBr"|jtDk(r|j |k(StFS)aw Compare the value of this literal with something else Either, with the value of another literal comparisons are then done in literal "value space", and according to the rules of XSD subtype-substitution/type-promotion OR, with a python object: basestring objects can be compared with plain-literals, or those with datatype xsd:string bool objects with xsd:boolean a int, long or float with numeric xsd types isodate date,time,datetime objects with xsd:date,xsd:time or xsd:datetime Any other operations returns NotImplemented TzII cannot know that these two lexical forms do not map to the same value: z and rFrUz4I don't know how to compare literals with datatypes )$rKr rr5rrPrNrkrrrbrr r r:_XML_COMPARABLE_isEqualXMLNoderWrrMr*rNrrrr/r0r2rr,rF_XSD_DAYTIMEDURATION_XSD_YEARMONTHDURATIONrC _XSD_BOOLEANry)rXrmrYrZs r?rnz Literal.eq8se, 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::dE*==K/  "V51 t $ s #}}(}} +t}}/D4yE))(%Y6 7}} 66zzU** h5 6}} 9 EEzzU** 84 5}}$&! zzU**  t $}} ,zzU**r@c&|j| SrB)rnrls r?rrz Literal.neqs775>!!r@c^|r|j|jS|jS)aZ Returns a representation in the N3 format. Examples:: >>> Literal("foo").n3() '"foo"' Strings with newlines or triple-quotes:: >>> Literal("foo\nbar").n3() '"""foo\nbar"""' >>> Literal("''\'").n3() '"\'\'\'"' >>> Literal('"""').n3() '"\\"\\"\\""' Language:: >>> Literal("hello", lang="en").n3() '"hello"@en' Datatypes:: >>> Literal(1).n3() '"1"^^' >>> Literal(1.0).n3() '"1.0"^^' >>> Literal(True).n3() '"true"^^' Datatype and language isn't allowed (datatype takes precedence):: >>> Literal(1, lang="en").n3() '"1"^^' Custom datatype:: >>> footype = URIRef("http://example.org/ns#foo") >>> Literal("1", datatype=footype).n3() '"1"^^' Passing a namespace-manager will use it to abbreviate datatype URIs: >>> from rdflib import Graph >>> Literal(1).n3(Graph().namespace_manager) '"1"^^xsd:integer' )qname_callback) _literal_n3rrWs r?rZz Literal.n3s2j ##3D3Q3Q#R R##% %r@c|r|jtvr|j|jtvrI t |}t j |st j|r|jd|S |jtk(rtddt |dS|jtk(r|}d|vr d|vr d|vr|dz }|S|jtk(r|jS|S|j}|j}d}||r||}|sd|d }|tvrj t |}t j |r"|j!d d j!d d }t j|r|j!d d}|j&}|r|d|S|r|d|S|S#t$r|jd|cYSwxYw#t$rt#j$d|YdwxYw)a_ Using plain literal (shorthand) output:: >>> 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: >>> 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:: >>> Literal(1)._literal_n3( ... qname_callback=lambda uri: "xsd:integer") '"1"^^xsd:integer' NFz\.?0*eer.Ez.0rrinfINFInfinitynanNaNzSerializing weird numerical @z^^)r_PLAIN_LITERAL_TYPESrP_NUMERIC_INF_NAN_LITERAL_TYPESrNmathisinfisnanrqr _XSD_DOUBLErr8rmrb _quote_encodereplacewarningswarnr) rX use_plainrpvrBencodedr quoted_dtrs r?rqzLiteral._literal_n3sb *>>zz%==$BBG!$K::a=DJJqM#'#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%AF;2A)G;GG!H?HcDd|vrX|jdd}d|vr|jdd}|ddk(r|ddk7r |dddzdz}d |jd d zSd |jdd jddjddjd d zS)N \z\\z"""z\"\"\"rz"""%s""" z\rz"%s"z\nz\")r)rXrs r?rzLiteral._quote_encode^s 4<ll40G}!//%=r{c!gbkT&9!#2,-3e << <DLLu5==dFKSSUgdE"# #r@ctj|g}|j'|jdt |jz|j '|jdt |j z|j tk(rd}n|j j}|ddj|dS)Nzlang=z datatype=zrdflib.term.Literalrz, r) rNrrappendreprrrr r]join)rXargsrs r?rzLiteral.__repr__ys T"# == $ KK$t}}"55 6 == $ KK d4==&99 : >>W $+Gnn--G!DIIdO,A..r@c6|j |jS|S)zV Returns an appropriate python datatype derived from this RDF Literal rrs r?rzLiteral.toPythons :: !::  r@)NNN) rrrrrrrrr\r )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]]])r$zTuple[Any, Dict[str, Any]]r\None)r;rr\r )r\rCr)r\rMrBr[)FN)rrCrpz+Optional[Callable[[URIRef], Optional[str]]]r\rNr)%r]r^r_r`rrarfrrrrPrrrr"r'rrHrJrrPrRrrzr}rrrcrrkrnrrrZrqrrrrUr@r?r r s{Yv KBI #"&$( UUU U " U  Un&   M L' fDPfP7,7(7&7,b"H  ""B$L1fzx"8&x FJkkDk kZ#6 /r@r ctjjjd|d}|j |S)Nzz)xmldomminidom parseStringr) xmlstringrs r? _parseXMLrs: WW__ ( ( !),DEF  Mr@c0tjtjjdd} |j |}|j|S#tj j $r}tjd||d}~wwxYw)a\ Parse the lexical form of an HTML literal into a document fragment using the ``dom`` from html5rdf tree builder. :param lexical_form: The lexical form of the HTML literal. :return: 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) lexical_formparserresultrss r? _parse_htmlrs  " " 1 1% 8F393G3G 3U  M    * * ,QC01sAB6BBc4tj|d}|S)z Serialize a document fragment representing an HTML literal into its lexical form. :param value: A document fragment representing an HTML literal. :return: The lexical form of the HTML literal. r)r)r serialize)rPrs r? _write_htmlrs  E 2F Mr@c|t|tjjjrItjjj }|xj |j z c_|}|jd}|jdr|dd}|jdr|dd}|dk(rd}|S) NrJs&&sisr@) rKrrrDocumentFragmentDocument childNodestoxmlr)xmlnoder&rBs r? _writeXMLrs'377??;;< GGOO $ $ & ***  gA ||=> bcF||./ bI ''  Hr@cXt|tr|j}t|SrB)rKrNencoderrs r? _unhexlifyrs"%  U r@cgd}gd}|j}||vry||vrtjd|dty) 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)r-false0falseTzParsing weird boolean, z does not map to True or False)categoryF)rbrr UserWarning)rPtrue_accepted_valuesfalse_accepted_values new_values r? _parseBooleanrsQ 8: I((-- %eY.L M   r@c |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. NrUlexicalrPs r?r r s  r@cPt|dkDxrt|txr|dk\S)zG xsd:unsignedInteger and xsd:unsignedLong must not be negative r)rrKr*rs r?_well_formed_unsignedlongrs( wr s/ D NU\\%;%;E%B$%N r@c`|jduxr|jjddu|fSrBr rs r?r r s/ D MU\\%;%;D%A%M r@c"|jSrB)rrs r?r r s EKKMr@z%Dict[Type[Any], Callable[[Any], Any]]rXr9_StrT)boundc.| |||fS|||fS|dfSrBrU)objpTypecastFuncdTypes r? _py2literalrs3 }e##  EzDyr@ctD]*\\}}}t||s||k(st||||cStD]$\}\}}t||st||||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)_SpecificPythonToXSDRulesrKr_GenericPythonToXSDRules)rrrrrs r?r r sv%>  c5 !ex&7sE8U; ;%>%=  % c5 !sE8U; ;%= 9r@rc4t|jSrB)rNrbis r?r r sc!fllnr@c |dS)Nr,rUrs r?r r s Aa5r@c"|jSrB isoformatrs r?r r s !++-r@c"|jSrBrrs r?r r  akkmr@c"|jSrBrrs r?r r r"r@ct|SrBr-rs r?r r s ,Q/r@ct|SrBr%rs r?r r s -a0r@zZList[Tuple[Type[Any], Tuple[Optional[Callable[[Any], Union[str, bytes]]], Optional[str]]]]rcB|jdjdS)Nz%Ystrftimezfillr;s r?r r sS\\$%7%=%=a%@r@cB|jdjdS)Nz%Y-%mr)r,s r?r r s#,,w*?*E*Ea*Hr@zPList[Tuple[Tuple[Type[Any], str], Optional[Callable[[Any], Union[str, bytes]]]]]rranyURIz3Dict[Optional[str], Optional[Callable[[str], Any]]]rariz6Dict[URIRef, Callable[[Union[str, bytes], Any], bool]]rrctjtjttjtj t tjtj ty)z; Reset lexical<->value space binding for `Literal` N) rclearupdaterarextend _OriginalGenericPythonToXSDRulesr!_OriginalSpecificPythonToXSDRulesrUr@r?_reset_bindingsr6QsTK(""$##$DE##%$$%FGr@c t|}| ||S t |S#t$rYywxYw#t$r tj d|d|dYywxYw#t $rt |dcYSwxYw)z~ Map 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_inforJ)rKeyErrorrrrrNr)rr conv_funcs r?rr_s$X.   W% % )w< -   NNLXJVbclbmn     " )w( (  )s, "1 A ..&AAA54A5_AnyTct|tr2|jddjddjddS|S)z~ Replaces , , (#x9 (tab), #xA (linefeed), and #xD (carriage return)) with space without any whitespace collapsing   rr)rKrNrrs r?rrsE"C( ''c2::4EMMdTWXX r@cpt|tr%tjdd|j S|S)Nz +r>)rKrNrerstripr?s r?rrs2"C(vvdC!1!7!7!9:: r@c|r | td|tvrtjd|d||}|t|<|rtj ||f|fyt j |||ffy)a register a new datatype<->pythontype binding :param constructor: an optional function for converting lexical forms into a Python instances, if not given the pythontype is used directly :param lexicalizer: an optional function for converting python objects to lexical form, if not given object.__str__ is used :param 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.)rrrrrrr)r pythontype constructor lexicalizerdatatype_specifics r?rrs*X-KLL##H:-LMN !,X!((:x*@+)NO ''k85L(MNr@c>eZdZdZdZd dZd dZd dZd d dZd dZ y)r zo A Variable - this is used for querying, or in Formula aware graphs, where Variables can be stored rUczt|dk(r td|ddk(r|dd}tj||S)Nrz7Attempted to create variable with empty string as name!?r+)rrrNrfrgs r?rfzVariable.__new__s@ u:?UV V 8s?!"IE{{3&&r@c|jturd}n|jj}|dtj |dS)Nzrdflib.term.Variablerr)rr r]rNrrs r?rzVariable.__repr__s? >>X %,Gnn--G!CLL./q11r@c d|zSNrJrUrs r?rzVariable.toPython Tzr@Nc d|zSrMrUrWs r?rZz Variable.n3rNr@c&tt|ffSrB)r rNrs r?rzVariable.__reduce__s3t9,''r@)rPrNr\r rrBr[)r\z!Tuple[Type[Variable], Tuple[str]]) r]r^r_r`rarfrrrZrrUr@r?r r s' I'2(r@r zDict[Type[Node], int]rx (c ddlm}fd}yjjk7ryj|j|jfvr|Sj|j k(rTt r`ttjjjsJttjjjsJjjk(rjjk(syjjDcgc] }|ddk7r|}}jjDcgc] }|ddk7r|}}t!|t!|k7ry|D]9}||vr2j#|d|dj#|d|dk(r9y|Sj|j$|j&|j(|j*fvrTt r4ttjjj,tjjj.tjjj0tjjj2fsJttjjj,tjjj.tjjj0tjjj2fsJj4j4k(Sj|j6k(rt r`ttjjj8sJttjjj8sJj4j4k(xrj:j:k(Sj|j<k(rj>j>k(Sj|j@k(rt r`ttjjjBsJttjjjBsJjDjDk(xrjFjFk(StIdjcc}wcc}w)Nr)rctjtjk7rytdjjD]\}}t||ryy)NFc ||fSrBrU)xys r?r z2_isEqualXMLNode..recurse.. s1vr@T)rrmaprj)ncocnoderms r?recursez _isEqualXMLNode..recurse sY t 3u'7'7#8 8-t@P@PQFB"2r*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_NODErrKrrrElementtagName namespaceURI attributeskeysNSrgetAttributeNS TEXT_NODE COMMENT_NODECDATA_SECTION_NODE NOTATION_NODETextComment CDATASectionNotationdataPROCESSING_INSTRUCTION_NODEProcessingInstructiontarget ENTITY_NODE nodeValueDOCUMENT_TYPE_NODE DocumentTypepublicIdsystemIdr)r]rmXMLNoder^kn_keyso_keyss`` r?rjrjs<0  |u} }}& }}..0N0NOOy '.. . dCGGOO$;$;< <<eSWW__%<%<= == LLEMM )d.?.?5CUCU.U__++- -t66 -  %%,,. .t66 .  v;#f+ %AV ''!ad3u7K7KAaDRSTURV7WW y ""   GGOO((GGOO++GGOO00GGOO,,  GGOO((GGOO++GGOO00GGOO,,  yyEJJ&& '== = dCGGOO$I$IJ JJeSWW__%J%JK KKyyEJJ&F4;;%,,+FF '-- -~~00 '44 4 dCGGOO$@$@A AAeSWW__%A%AB BB}}.R4==ENN3RRDT]]OTUUI  s (TT )r=rNr\rC)rFrNr\rC)rPUnion[str, bytes]r\rCr)rrNr\zxml.dom.minidom.Document)rrNr\ xml.dom.minidom.DocumentFragment)rPrr\rL)rzAUnion[xml.dom.minidom.Document, xml.dom.minidom.DocumentFragment]r\rL)rPzUnion[str, bytes, Literal]r\rL)rrrPrr\rC) rrrrrzOptional[Callable[[Any], Any]]rzOptional[_StrT]r\zTuple[Any, Optional[_StrT]])rrrrr\zTuple[Any, Optional[str]])r\r)rrrrr\r)rr;r\r;)NNF) rrNrDz Type[Any]rEzOptional[Callable[[str], Any]]rFz,Optional[Callable[[Any], Union[str, bytes]]]rGrCr\r)r]Union[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]rmrr\rC)r` __future__rrbrA fractionsr__all__loggingr}rr_rbase64rrbinasciirr collectionsrrrrrrrrrtypesrtypingrrrrrr r!r"r#r$r% urllib.parser&r'r(uuidr)r rdflib.util rdflib.compatr* xsd_datetimer,r-r.r/r0r1r2r3 namespacer4pathsr5r6r7r8r9 _HAS_HTML5RDFr ImportErrorr getLoggerr]rrrr:rr<rrDrGrSABCrrNr rr rrrr r rrrrrrr rrrrrrrrrrrr_XSD_PFX_RDF_PFX_RDF_XMLLITERAL_RDF_HTMLLITERALr:r r _XSD_FLOATrr8 _XSD_INTEGERrmr/r0r2rFrkrl _OWL_RATIONAL_XSD_B64BINARY_XSD_HEXBINARY _XSD_GYEAR_XSD_GYEARMONTHr5r{r|rr1r4rrrrXr9rrr rNrCrMrrrlistr4rLrr5rarirrr2r6rr;rrrr rxrjrUr@r?rs .#   ''#44    65 #   +PP M7   8 $$ 2 #9:,$S377SesePZ&x=^x=v F %( U2NU2pyjyx#,  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 8g  #D  8l "#%9 #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)#D* 8' '()+#D, 8e c-#D. 8n $%y/#D0 8' '()1#D2 8g 3#D4 8m #$c5#D6 8f s7#D8 8o %&9#D: 8n $%s;#D< 8g =#D> 8h ?#D@ 8n $%yA#DB 8h C#DDYE#D @#J %0K !+: 8n $%'@ 8o %&(B 8n $%'@ TP IKEJ $ H$) $)*:$)$)N s#37@D# !O!O!O0!O> !O  !O  !OH(z(J$/s#3 3 %Xr62wCDKV KV KV6 7KV[DHs]//]:9]: