3 dF@sdZddlmZddlmZddlmZddlmZdddd d d d d gZddlZej e Z ddl Z ddl Z ddlZddlZddlmZmZmZmZddlmZmZddlmZddlmZddlmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&Z&ddl'm(Z(ddl'm)Z)ddl'm*Z*ddl+m,Z,ddl'm-Z-ddl'm.Z.ddl/m0Z0ddl/m1Z1ddl/m2Z2dZ3dZ4iZ5d Z6d!d"Z7ed#Z8d$d%Z9d&d'Z:Gd(dde;ZGd+d,d,e>Z?Gd-d.d.e?Z@d/d0ZAd1d2ZBGd3d d e=ZCGd4d d e=ZDd5d6ZEd7d8ZFd9d:ZGd;d<ZHd=d>ZId?ZJd@ZKe>eKdAZLe>eKdBZMe>eJdCZNe>eJdDZOe>eJdEZPe>eJdFZQe>eJdGZRe>eJdHZSe>eJdIZTe>eJdJZUe>eJdKZVe>eJdLZWe>eJdMZXe>eJdNZYe>dOZZe>eJdPZ[eReQePe>eJdDe>eJdQe>eJdRe>eJdSe>eJdTe>eJdUe>eJdVe>eJdWe>eJdXe>eJdYe>eJdZe>eJd[e>eJd\fZ\eReSePeQeZfZ]e>eJdDePeQfZ^ed]d^ed_d^ej_j`jad`d^iZbeNeLeMe>eJdae>eJdbfZcdcddZddedfZeddglfmgZge-dfehdePffeidhd^eSffejdeRffe,deRffegdeQffedid^eTffedjd^eUffedkd^eVffe dld^eWffedmd^eXffej_j`jaeGeLffej_j`jkeGeMffedeZffgZle-e[fe$fgZme)remjneoe[fe$fdde>eJdKee>eJdJee>eJdnee>eJdoee>eJdIee>eJdLe!e>eJdMe!e>eJdNe!e>eJdPeHe>eJdCde>eJdade>eJdbde>eJdpde>eJdHeIe>eJdFege>eJdGe,e>eJdVeje>eJdSe,e>eJdUeje>eJdTeje>eJdRe,e>eJd[e,e>eJdWeje>eJdXeje>eJdZe,e>eJdQeje>eJd\eje>eJdYeje>eJdDehe>eJdEehe>eJdqdrd^e>eJdsdeLeEeMeFi#ZpiZqeqjrepdtduZsddwdZtGdxd d e=ZuGdyd d ed|eDd}id~dZye dkrddlzZzezj{dS)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 )absolute_import)division)print_function)FractionbindNode IdentifierURIRefBNodeLiteralVariable StatementN)datetimedatetime timedelta)subcompile) defaultdict)category) parse_time parse_dateparse_datetimeDurationparse_durationduration_isoformat)hexlify unhexlify)PY2)PY3)b) long_type) string_types) text_type) urldefrag)urljoin)urlparsez/.well-known/genid/z/.well-known/genid/rdflib/z <>" {}|\^`cCsttdd|S)NcSst|dkp|tkS)N)ord_invalid_uri_chars)cr+-/tmp/pip-build-7vycvbft/rdflib/rdflib/term.pyOsz_is_valid_uri..)allmap)urir+r+r, _is_valid_uriNsr1z^[a-zA-Z]+(?:-[a-zA-Z0-9]+)*$cCsttj|S)N)bool_lang_tag_regexmatch)tagr+r+r,_is_valid_langtagUsr6c Cs\t|trt|dd}}ntr,t|}}n t|}}y ||Wntk rVdSXdS)z[ Verify that the provided value can be converted into a Python unicode object. decodezutf-8FT) isinstancebytesgetattrrstrunicode UnicodeError)valueZ coding_funcparamr+r+r,_is_valid_unicodeYs    r@c@seZdZdZfZdS)rz A Node in the Graph. N)__name__ __module__ __qualname____doc__ __slots__r+r+r+r,rmsc@sbeZdZdZfZddZddZddZdd Zd d Z d d Z ddZ ddZ ddZ ejZdS)rzg See http://www.w3.org/2002/07/rdf-identifer-terminology/ regarding choice of terminology. cCs tj||S)N)r#__new__)clsr>r+r+r,rF}szIdentifier.__new__cCs |j|S)zNA "semantic"/interpreted equality function, by default, same as __eq__)__eq__)selfotherr+r+r,eqsz Identifier.eqcCs |j|S)zOA "semantic"/interpreted not equal function, by default, same as __ne__)__ne__)rIrJr+r+r,neqszIdentifier.neqcCs |j| S)N)rH)rIrJr+r+r,rLszIdentifier.__ne__cCs(t|t|kr t|t|kSdSdS)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 FN)typer#)rIrJr+r+r,rHszIdentifier.__eq__cCsR|dkr dSt|t|kr,t|t|kSt|trNtt|tt|kStS)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 NT)rNr#r8r _ORDERINGNotImplemented)rIrJr+r+r,__gt__s  zIdentifier.__gt__cCsR|dkr dSt|t|kr,t|t|kSt|trNtt|tt|kStS)NF)rNr#r8rrOrP)rIrJr+r+r,__lt__s zIdentifier.__lt__cCs|j|}|rdS||kS)NT)rR)rIrJrr+r+r,__le__s zIdentifier.__le__cCs|j|}|rdS||kS)NT)rQ)rIrJrSr+r+r,__ge__s zIdentifier.__ge__N)rArBrCrDrErFrKrMrLrHrQrRrTrUr#__hash__r+r+r+r,rus  cseZdZdZfZdddZddZdddZd d Zd d Z d dZ e rPddZ fddZ ddZddZddZddZZS)r zT RDF URI Reference: http://www.w3.org/TR/rdf-concepts/#section-Graph-URIref Nc Cs|dk r6|jd}t||dd}|r6|jds6|d7}t|sLtjd|ytj||}Wn"tk r~tj||d}YnX|S)N#)allow_fragmentszG%s does not look like a valid URI, trying to serialize this will break.zutf-8)endswithr%r1loggerwarningr#rFUnicodeDecodeError)rGr>baseZ ends_in_hashrtr+r+r,rFs  zURIRef.__new__cCst|S)N)r#)rIr+r+r,toPythonszURIRef.toPythoncCs.t|std||r"|j|Sd|SdS)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 zn"%s" does not look like a valid URI, I cannot serialize this as N3/Turtle. Perhaps you wanted to urlencode it?z<%s>N)r1 Exception normalizeUri)rInamespace_managerr+r+r,n3s   z URIRef.n3cCs$d|krt|\}}t|S|SdS)NrW)r$r )rIurlfragr+r+r,defrags z URIRef.defragcCstt|ffS)N)r r#)rIr+r+r, __reduce__ szURIRef.__reduce__cCs t|fS)N)r#)rIr+r+r,__getnewargs__szURIRef.__getnewargs__cCs|jS)N)encode)rIr+r+r,__str__szURIRef.__str__cs.|jtkrd}n|jj}d|tt|jfS)Nzrdflib.term.URIRefz%s(%s)) __class__r rAsuper__repr__)rIclsName)rlr+r,rns zURIRef.__repr__cCs|jt||S)N)rlr#)rIrJr+r+r,__add__szURIRef.__add__cCs|j|t|S)N)rlr#)rIrJr+r+r,__radd__!szURIRef.__radd__cCs|jt||S)N)rlr#)rIrJr+r+r,__mod__$szURIRef.__mod__cCstt|tr.td|}t|jttddSt|trdd|}|tkrPt|St}|t|<|Sn t d|dS)a Create 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 z%sN)r>z<%s> is not a skolem URI) r8 RDFLibGenidr&r pathlenrdflib_skolem_genidGenidskolemsra)rI parsed_uriZbnode_idretvalr+r+r, de_skolemize's   zURIRef.de_skolemize)N)N)rArBrCrDrErFr`rdrgrhrirrkrnrprqrrr{ __classcell__r+r+)rlr,r s   c@seZdZfZeddZdS)rwcCs6t|tst|}t|}|jjt}|dkr2dSdS)NrFT)r8r"r;r&rtrfind skolem_genid)r0rygen_idr+r+r,_is_external_skolemBs  zGenid._is_external_skolemN)rArBrCrE staticmethodrr+r+r+r,rw?srwc@seZdZfZeddZdS)rscCsXt|tst|}t|}|jdks8|jdks8|jdkr._generator)uuidr)rr+)rr,_serial_number_generatorls  rc@sheZdZdZfZdeefddZddZdddZ d d Z d d Z e rRd dZ ddZdddZdS)r zM Blank Node: http://www.w3.org/TR/rdf-concepts/#section-blank-nodes NcCs(|dkr|}d||f}ntj||S)zE # only store implementations should pass in a value Nz%s%s)rrF)rGr>Z_sn_gen_prefixZnode_idr+r+r,rFs z BNode.__new__cCst|S)N)r#)rIr+r+r,r`szBNode.toPythoncCsd|S)Nz_:%sr+)rIrcr+r+r,rdszBNode.n3cCs t|fS)N)r#)rIr+r+r,riszBNode.__getnewargs__cCstt|ffS)N)r r#)rIr+r+r,rhszBNode.__reduce__cCs|jS)N)rj)rIr+r+r,rksz BNode.__str__cCs(|jtkrd}n|jj}d|t|fS)Nzrdflib.term.BNodez%s('%s'))rlr rAr;)rIror+r+r,rns zBNode.__repr__cCs6|dkr d}|dkrt}d|t|f}tt||S)z Create a URIRef "skolem" representation of the BNode, in accordance with http://www.w3.org/TR/rdf11-concepts/#section-skolemization .. versionadded:: 4.0 Nzhttp://rdlib.net/z%s%s)rvr#r r%)rI authorityZbasepathZskolemr+r+r, skolemizes zBNode.skolemize)N)NN)rArBrCrDrErrrFr`rdrirhrrkrnrr+r+r+r,r xs cs.eZdZdZesdDZndEZdFd d Zd d Zed dZ eddZ eddZ ddZ ddZ ddZddZddZereZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6ZdGd7d8Z dHd:d;Z!dd?Z#fd@dAZ$dBdCZ%Z&S)Ir a RDF Literal: http://www.w3.org/TR/rdf-concepts/#section-Graph-Literal The lexical value of the literal is the unicode object The interpreted, datatyped value is available from .value Language tags must be valid according to :rfc:5646 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 PY2.X some stable order will be made up by python 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(u'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 either make up an ordering (py2.x) or throw a TypeError (py3k): >>> Literal(1).__gt__(2.0) NotImplemented languagedatatyper> _language _datatype_valueNc Cs~|dkr d}|dk r|ntj}|dk r6|dk r6td|rPt| rPtd||r\t|}d}t|tr|pr|j}|rt ||}n |j }|j }nt|t st rt|trt ||}|dk r|rt||\}}|dk rt|r|}n2|}t||\}}|p|}|dk r |}|rd}t r2t|tr2|jd}ytj||}Wn$tk rftj||d}YnX||_||_||_|S)NrzmA Literal can only have one of lang or datatype, per http://www.w3.org/TR/rdf-concepts/#section-Graph-Literalz!'%s' is not a valid language tag!zutf-8)rdflibZNORMALIZE_LITERALS TypeErrorr6rar r8r r_castLexicalToPythonrr>r"rr9_castPythonToLiteralr@r7r#rFr]rrr) rGZlexical_or_valuelangr normalizer>rrinstr+r+r,rFsP        zLiteral.__new__cCs&|jdk rt|j|j|jdS|SdS)a< 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(u'1', datatype=rdflib.term.URIRef(u'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(u'a', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) N)rr)r>r rr)rIr+r+r,rUs zLiteral.normalizecCs|jS)N)r)rIr+r+r,r>hsz Literal.valuecCs|jS)N)r)rIr+r+r,rlszLiteral.languagecCs|jS)N)r)rIr+r+r,rpszLiteral.datatypecCstt||j|jffS)N)r r#rr)rIr+r+r,rhtszLiteral.__reduce__cCsdt|j|jdfS)N)rr)dictrr)rIr+r+r, __getstate__wszLiteral.__getstate__cCs |\}}|d|_|d|_dS)Nrr)rr)rIarg_dr+r+r, __setstate__zs zLiteral.__setstate__c Cs|dkr |St|tst|}|j|jkrHt|j|j|j|jdS|jtkr|jtkrttdtt|jt|jdjdjdt dSyt j ||}Wn&t k rt |jt |}YnX|jtkr|j}nt}t||j|dSdS)z >>> Literal(1) + 1 rdflib.term.Literal(u'2', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) >>> Literal("1") + "1" rdflib.term.Literal(u'11') N)rz%f0.)r8r rr`r_NUMERIC_LITERAL_TYPESDecimalroundrstrip _XSD_DECIMALr#rprr;r>_STRING_LITERAL_TYPES _XSD_STRING)rIvalsZ new_datatyper+r+r,rps(     . zLiteral.__add__cCs |jdk rt|jSt|dkS)zc Is the Literal "True" This is used for if statements, bool(literal), etc. Nr)r>r2ru)rIr+r+r,__bool__s  zLiteral.__bool__cCs4t|jtttfr t|jjStdt|dS)a >>> (- Literal(1)) rdflib.term.Literal(u'-1', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) >>> (- Literal(10.5)) rdflib.term.Literal(u'-10.5', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#double')) >>> from rdflib.namespace import XSD >>> (- Literal("1", datatype=XSD.integer)) rdflib.term.Literal(u'-1', datatype=rdflib.term.URIRef(u'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(u'1') >>> zNot a number; %sN) r8r>intr!floatr __neg__rrepr)rIr+r+r,rszLiteral.__neg__cCs4t|jtttfr t|jjStdt|dS)a >>> (+ Literal(1)) rdflib.term.Literal(u'1', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) >>> (+ Literal(-1)) rdflib.term.Literal(u'-1', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) >>> from rdflib.namespace import XSD >>> (+ Literal("-1", datatype=XSD.integer)) rdflib.term.Literal(u'-1', datatype=rdflib.term.URIRef(u'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(u'1') zNot a number; %sN) r8r>rr!rr __pos__rr)rIr+r+r,rszLiteral.__pos__cCs4t|jtttfr t|jjStdt|dS)a >>> abs(Literal(-1)) rdflib.term.Literal(u'1', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) >>> from rdflib.namespace import XSD >>> abs( Literal("-1", datatype=XSD.integer)) rdflib.term.Literal(u'1', datatype=rdflib.term.URIRef(u'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(u'1') zNot a number; %sN) r8r>rr!rr __abs__rr)rIr+r+r,rszLiteral.__abs__cCs4t|jtttfr t|jjStdt|dS)a% >>> ~(Literal(-1)) rdflib.term.Literal(u'0', datatype=rdflib.term.URIRef(u'http://www.w3.org/2001/XMLSchema#integer')) >>> from rdflib.namespace import XSD >>> ~( Literal("-1", datatype=XSD.integer)) rdflib.term.Literal(u'0', datatype=rdflib.term.URIRef(u'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(u'1') zNot a number; %sN) r8r>rr!rr __invert__rr)rIr+r+r,rszLiteral.__invert__c Csl|dkr dSt|trT|jtkr8|jtkr8|j|jkS|jp@t}|jpJt}||krftjr^tS||kS|j |j kr|j s|dS|j sdS|j |j kS|jdk o|jdk rt |jt krt t |j}||j||jkSy |j|jkSt k rYnXt |t |krt |t |kS|j|jkrP|js8dS|jsDdS|j|jkSdSt|trddStSdS)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 NTF)r8r rrr>rrDAWG_LITERAL_COLLATIONrPrrN_TOTAL_ORDER_CASTERSrr#r)rIrJdtselfdtotherZcasterr+r+r,rQ sL$           zLiteral.__gt__c CsV|dkr dSt|trDy|j| o.|j| Stk rBtSXt|trRdStS)NF)r8r rQrKrrPr)rIrJr+r+r,rRjs  zLiteral.__lt__c Cs6|j|}|rdSy |j|Stk r0tSXdS)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 TN)rRrKrrP)rIrJrSr+r+r,rTws  zLiteral.__le__c Cs6|j|}|rdSy |j|Stk r0tSXdS)NT)rQrKrrP)rIrJrSr+r+r,rUs  zLiteral.__ge__cCst|tr|jr<|jr<|jtks*|jtkr|j|jkrdSnJ|jtkoL|j sb|jtkrf|j rfdS|jpndj|jpzdjkrdSdS)zo Helper method to decide which things are meaningful to rich-compare with this literal FrT)r8r r XSDToPythonrrlower)rIrJr+r+r,_comparable_tos   zLiteral._comparable_tocCs:tj|}|jr"|t|jjN}|jr6|t|jN}|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) )r#rVrhashrr)rIresr+r+r,rVs  zLiteral.__hash__cCsf||kr dS|dkrdSt|trb|j|jko`|jr>|jjnd|jrP|jjndko`tj||SdS)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)r8r rrrr#rH)rIrJr+r+r,rHs$  ( zLiteral.__eq__cCsLt|trL|jtkr`|jtkr`|jdk r@|jdk r@|j|jkStj||rPdStd||f|jphdj |jptdj krdS|jpt }|jpt }|t kr|t krtj||S||krt j rtd|j|jfndS|jdk o|jdk r|jt tfkr t|j|jS|j|jkStj||r*dS|jt kr:dStd||fnt|tr\dSt|tr|jdk rxdS|jt ks|jdkrHt||kSnt|tttfr|jtkrH|j|kSnt|tttfr|jtttfkrH|j|kSnPt|ttfr&|jtttfkrH|j|kSn"t|t rH|jt!krH|j|kSt"S)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 NTzRI cannot know that these two lexical forms do not map to the same value: %s and %srFz=I don't know how to compare literals with datatypes %s and %s)#r8r rrr>r#rHrrrrrr_RDF_XMLLITERAL_RDF_HTMLLITERAL_isEqualXMLNoderr"rr!rrrr _XSD_DATETIME _XSD_DATE _XSD_TIMErr _XSD_DURATION_XSD_DAYTIMEDURATION_XSD_YEARMONTHDURATIONr2 _XSD_BOOLEANrP)rIrJrrr+r+r,rKsd                    z Literal.eqcCs |j| S)N)rK)rIrJr+r+r,rM`sz Literal.neqcCs|r|j|jdS|jSdS)ae Returns a representation in the N3 format. Examples:: >>> Literal("foo").n3() u'"foo"' Strings with newlines or triple-quotes:: >>> Literal("foo\nbar").n3() u'"""foo\nbar"""' >>> Literal("''\'").n3() u'"\'\'\'"' >>> Literal('"""').n3() u'"\\"\\"\\""' Language:: >>> Literal("hello", lang="en").n3() u'"hello"@en' Datatypes:: >>> Literal(1).n3() u'"1"^^' >>> Literal(1.0).n3() u'"1.0"^^' >>> Literal(True).n3() u'"true"^^' Datatype and language isn't allowed (datatype takes precedence):: >>> Literal(1, lang="en").n3() u'"1"^^' Custom datatype:: >>> footype = URIRef("http://example.org/ns#foo") >>> Literal("1", datatype=footype).n3() u'"1"^^' Passing a namespace-manager will use it to abbreviate datatype URIs: >>> from rdflib import Graph >>> Literal(1).n3(Graph().namespace_manager) u'"1"^^xsd:integer' )qname_callbackN) _literal_n3rb)rIrcr+r+r,rdcs5z Literal.n3Fc Cs|r|jtkr|jdk r|jtkrly,t|}tj|s@tj|rL|jd|SWnt k rj|jd|SX|jt krt dddt|S|jt krd|}d|kr|d7}|S|jt krd|jSd|S|j}|j}d}|rt|r||}|sd |}|tkrtyDt|}tj|r4|jd d jd d }tj|rL|jd d}Wn$t k rrtjd|YnX|j}|rd||fS|rd||fSd|SdS)aj Using plain literal (shorthand) output:: >>> from rdflib.namespace import XSD >>> Literal(1)._literal_n3(use_plain=True) u'1' >>> Literal(1.0)._literal_n3(use_plain=True) u'1e+00' >>> Literal(1.0, datatype=XSD.decimal)._literal_n3(use_plain=True) u'1.0' >>> Literal(1.0, datatype=XSD.float)._literal_n3(use_plain=True) u'"1.0"^^' >>> Literal("foo", datatype=XSD.string)._literal_n3( ... use_plain=True) u'"foo"^^' >>> Literal(True)._literal_n3(use_plain=True) u'true' >>> Literal(False)._literal_n3(use_plain=True) u'false' >>> Literal(1.91)._literal_n3(use_plain=True) u'1.91e+00' Only limited precision available for floats: >>> Literal(0.123456789)._literal_n3(use_plain=True) u'1.234568e-01' >>> Literal('0.123456789', ... datatype=XSD.decimal)._literal_n3(use_plain=True) u'0.123456789' Using callback for datatype QNames:: >>> Literal(1)._literal_n3( ... qname_callback=lambda uri: "xsd:integer") u'"1"^^xsd:integer' NFz\.?0*eez%ez%srz.0z<%s>infZINFInfinitynanNaNzSerializing weird numerical %rz%s@%sz%s^^%s)r_PLAIN_LITERAL_TYPESr>_NUMERIC_INF_NAN_LITERAL_TYPESrmathisinfisnanr ValueError _XSD_DOUBLErrrr _quote_encodereplacewarningswarnr) rIZ use_plainrvrencodedrZ quoted_dtrr+r+r,rsV-            zLiteral._literal_n3cCsd|krd|jdd}d|kr(|jdd}|ddkrT|ddkrT|dddd}d |jd d Sd |jdd jddjddjd d SdS)N \z\\z"""z\"\"\"rX"z"""%s""" z\rz"%s"z\nz\"r)r)rIrr+r+r,rs   zLiteral._quote_encodecCs|jS)N)rj)rIr+r+r,rk"szLiteral.__str__csvtt|jg}|jdk r.|jdt|j|jdk rL|jdt|j|jtkr\d}n|jj}d|dj |fS)Nzlang=%sz datatype=%szrdflib.term.Literalz%s(%s)z, ) rmr rnrappendrrrlrAjoin)rIargsro)rlr+r,rn%s   zLiteral.__repr__cCs|jdk r|jS|S)zV Returns an appropriate python datatype derived from this RDF Literal N)r>)rIr+r+r,r`1s zLiteral.toPython)rrr>rrr)rrr)NNN)N)FN)'rArBrCrDrrErFrpropertyr>rrrhrrrprr __nonzero__rrrrrQrRrTrUrrVrHrKrMrdrrrkrnr`r|r+r+)rlr,r sJU @   0 ]  %/d : i cCs,tr|jd}tjjjd|}|j|S)Nzutf-8z1%s)rrjxmldomminidom parseStringr)Z xmlstringrzr+r+r, _parseXML;s   rc CsTy2ddl}|j|jjdd}|j|}|j|Stk rNtdYnXdS)Nrr)treez*HTML5 parser not available. Try installingz- html5lib zWHTML5 parser not available. Try installing html5lib )html5lib HTMLParser treebuildersgetTreeBuilder parseFragmentr ImportError)Zhtmltextrparserrzr+r+r, _parseHTMLDs rcCst|tjjjr0tjjj}|j|j7_|}|jd}|jt drT|dd}|jt drn|dd }|t dkrt d}|S) Nzutf-8z&&zzri) r8rrrDocumentFragmentDocument childNodestoxml startswithr )Zxmlnoderrr+r+r, _writeXMLRs     rcCstrt|tr|j}t|S)N)rr8r;rjr)r>r+r+r, _unhexlifydsrcCsBddg}ddg}|j}||kr$dS||kr>tjd|tddS) N1truerfalseTz8Parsing weird boolean, % r does not map to True or False)rF)rrrDeprecationWarning)r>Ztrue_accepted_valuesZfalse_accepted_valuesZ new_valuer+r+r, _parseBooleanjsrz!http://www.w3.org/2001/XMLSchema#z+http://www.w3.org/1999/02/22-rdf-syntax-ns#Z XMLLiteralZHTMLstringrdoubledecimalintegerbooleanZdateTimerrdurationZdayTimeDurationZyearMonthDurationz&http://www.w3.org/2002/07/owl#rationalZ hexBinaryZbyterlongZnegativeIntegerZnonNegativeIntegerZnonPositiveIntegerZpositiveIntegershortZ unsignedByteZ unsignedIntZ unsignedLongZ unsignedShortcCs|jdk o|jj|dk |fS)N)tzinfo utcoffset)r>r+r+r,r-sr-cCs|jdk o|jjddk |fS)N)rr)r>r+r+r,r-scCs|jS)N)r)r>r+r+r,r-sZnormalizedStringtokencCs(|r|||fS|r||fS|dfSdS)Nr+)objpTypecastFuncdTyper+r+r, _py2literals  rcCslx4tD],\\}}}t||r||krt||||SqWx,tD]$\}\}}t||rpythontype 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 '%s' was already bound. Rebinding.)rarr[r\rrr)rZ pythontype constructorZ lexicalizerZdatatype_specificr+r+r,rPs csFeZdZdZfZddZfddZddZd d d Zd d Z Z S)r zy A Variable - this is used for querying, or in Formula aware graphs, where Variables can stored in the graph cCs8t|dkrtd|ddkr,|dd}tj||S)Nrz7Attempted to create variable with empty string as name!?rX)rurar#rF)rGr>r+r+r,rFvs    zVariable.__new__cs.|jtkrd}n|jj}d|tt|jfS)Nzrdflib.term.Variablez%s(%s))rlr rArmrn)rIro)rlr+r,rn~s zVariable.__repr__cCsd|S)Nz?%sr+)rIr+r+r,r`szVariable.toPythonNcCsd|S)Nz?%sr+)rIrcr+r+r,rdsz Variable.n3cCstt|ffS)N)r r#)rIr+r+r,rhszVariable.__reduce__)N) rArBrCrDrErFrnr`rdrhr|r+r+)rlr,r os  c@s$eZdZddZddZddZdS)r cCs0|\}}}tjdtddtj||||f|fS)Nz6Class Statement is deprecated, and will be removed in z7the future. If you use this please let rdflib-dev know!r)r stacklevelzmClass Statement is deprecated, and will be removed in the future. If you use this please let rdflib-dev know!)rrrtuplerF)rGZtriplecontextsubject predicateobjectr+r+r,rFs   zStatement.__new__cCst|d|dffS)NrrX)r )rIr+r+r,rhszStatement.__reduce__cCs|d|dfS)NrrXr+)rIr+r+r,r`szStatement.toPythonN)rArBrCrFrhr`r+r+r+r,r s (csddlm}fdd}dks*dkr.dSjjkr>dSj|j|jgkrV|Sj|jkrjjkozjjksdSddjj D}ddjj D}t |t |krdSx@|D]8}||koj |d|d j |d|d ksdSqW|Sj|j |j |j|jgkr,jjkSj|jkrTjjkoRjjkSj|jkrnjjkSj|jkrjjkojjjkStd jdS) Nr)rcsLtjtjkrdSx.tddjjD]\}}t||s.dSq.WdS)NFcSs||fS)Nr+)xyr+r+r,r-sz2_isEqualXMLNode..recurse..T)rurr/r)Zncoc)noderJr+r,recurses z _isEqualXMLNode..recurseFcSsg|]}|ddkr|qS)rzhttp://www.w3.org/2000/xmlns/r+).0kr+r+r, sz#_isEqualXMLNode..cSsg|]}|ddkr|qS)rzhttp://www.w3.org/2000/xmlns/r+)r0r1r+r+r,r2srXz,I dont know how to compare XML Node type: %s)xml.dom.minidomrZnodeTypeZ DOCUMENT_NODEZDOCUMENT_FRAGMENT_NODEZ ELEMENT_NODEZtagNameZ namespaceURI attributesZkeysNSruZgetAttributeNSZ TEXT_NODEZ COMMENT_NODEZCDATA_SECTION_NODEZ NOTATION_NODEdataZPROCESSING_INSTRUCTION_NODEtargetZ ENTITY_NODEZ nodeValueZDOCUMENT_TYPE_NODEpublicIdsystemIdsystemZIdra)r.rJrr/Zn_keysZo_keysr1r+)r.rJr,rsF         r__main__)NN)NNF)|rD __future__rrrZ fractionsr__all__logging getLoggerrAr[rrrr3rrrrrrerr collectionsr unicodedatarZisodaterrrrrrbinasciirrrsixrrr Z rdflib.compatr!r"r#Zsix.moves.urllib.parser$r%r&r~rvrxr)r1r3r6r@r&rrr rwrsrrr r rrrrrZ_XSD_PFXZ_RDF_PFXrrrZ _XSD_FLOATrrZ _XSD_INTEGERrrrrrrrZ _OWL_RATIONALZ_XSD_HEXBINARYrrrrrrrrrrr rrr2rrrrrr9rrupdaterrr r"r rOrdoctesttestmodr+r+r+r,sp                 bh  @                                                                       ! L