ciddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z ddlm Z dd lm Z dd lmZe jZeZgd ZGd d e j$ZGddeZGddeZGdde j$ZGdde j$ZGddeZGdde j$ZGdde j$ZGdde j$ZGddeZGd d!e j<ZGd"d#eZ Gd$d%eZ!Gd&d'e j<Z"Gd(d)e"Z#Gd*d+e"Z$Gd,d-e$Z%Gd.d/eZ&y)0N)error)eoo)integer)base) constraint) namedtype)namedval)tag)tagmap)IntegerBoolean BitString OctetStringNullObjectIdentifierReal EnumeratedSequenceOfAndSetOfBase SequenceOfSetOfSequenceAndSetBaseSequenceSetChoiceAnyNoValuenoValuec:eZdZdZej ej ejejdZ e jZ e jZej"j%ZefdZdZdZdZdZdZd Zd Zd Zd Zd ZdZ dZ!dZ"dZ#dZ$dZ%d1dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-ej"j\Z.dZ/dZ0dZ1d Z2d!Z3d"Z4d#Z5d2d$Z6d%Z7d&Z8d'Z9d(Z:d)Z;d*Zd-Z?d.Z@d/ZAd0ZBy)3r aCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`int` objects. Keyword Args ------------ value: :class:`int`, :class:`str` or |ASN.1| object Python :class:`int` or :class:`str` literal or |ASN.1| class instance. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. namedValues: :py:class:`~pyasn1.type.namedval.NamedValues` Object representing non-default symbolic aliases for numbers Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class ErrorCode(Integer): ''' ASN.1 specification: ErrorCode ::= INTEGER { disk-full(1), no-disk(-1), disk-not-formatted(2) } error ErrorCode ::= disk-full ''' namedValues = NamedValues( ('disk-full', 1), ('no-disk', -1), ('disk-not-formatted', 2) ) error = ErrorCode('disk-full') c ld|vr|j|d<tjj||fi|y)N namedValues)r!rSimpleAsn1Type__init__selfvaluekwargss 7/tmp/pip-target-z3e9_cxr/lib/python/pyasn1/type/univ.pyr#zInteger.__init__es5  &$($4$4F= ! $$T5;F;c>|j|j|zSNclone_valuer%r&s r(__and__zInteger.__and__kzz$++-..r)c>|j||jzSr+r,r/s r(__rand__zInteger.__rand__nzz%$++-..r)c>|j|j|zSr+r,r/s r(__or__zInteger.__or__qr1r)c>|j||jzSr+r,r/s r(__ror__zInteger.__ror__tr4r)c>|j|j|z Sr+r,r/s r(__xor__zInteger.__xor__wr1r)c>|j||jz Sr+r,r/s r(__rxor__zInteger.__rxor__zr4r)c>|j|j|zSr+r,r/s r( __lshift__zInteger.__lshift__}zz$++.//r)c>|j|j|z Sr+r,r/s r( __rshift__zInteger.__rshift__r?r)c>|j|j|zSr+r,r/s r(__add__zInteger.__add__r1r)c>|j||jzSr+r,r/s r(__radd__zInteger.__radd__r4r)c>|j|j|z Sr+r,r/s r(__sub__zInteger.__sub__r1r)c>|j||jz Sr+r,r/s r(__rsub__zInteger.__rsub__r4r)c>|j|j|zSr+r,r/s r(__mul__zInteger.__mul__r1r)c>|j||jzSr+r,r/s r(__rmul__zInteger.__rmul__r4r)c>|j|j|zSr+r,r/s r(__mod__zInteger.__mod__r1r)c>|j||jzSr+r,r/s r(__rmod__zInteger.__rmod__r4r)NcN|jt|j||Sr+r-powr.r%r&modulos r(__pow__zInteger.__pow__szz#dkk5&9::r)cL|jt||jSr+rSr/s r(__rpow__zInteger.__rpow__szz#eT[[122r)c>|j|j|zSr+r,r/s r( __floordiv__zInteger.__floordiv__r?r)c>|j||jzSr+r,r/s r( __rfloordiv__zInteger.__rfloordiv__szz%4;;.//r)c2t|j|z Sr+rr.r/s r( __truediv__zInteger.__truediv__sDKK%'((r)c2t||jz Sr+r_r/s r( __rtruediv__zInteger.__rtruediv__sEDKK'((r)cL|jt|j|Sr+r-divmodr.r/s r( __divmod__zInteger.__divmod__szz&e455r)cL|jt||jSr+rdr/s r( __rdivmod__zInteger.__rdivmod__szz& 455r)c,t|jSr+intr.r%s r(__int__zInteger.__int__4;;r)c,t|jSr+floatr.rls r( __float__zInteger.__float__T[[!!r)cJ|jt|jSr+)r-absr.rls r(__abs__zInteger.__abs__szz#dkk*++r)c,t|jSr+rjrls r( __index__zInteger.__index__rnr)c:|j|jSr+r,rls r(__pos__zInteger.__pos__zz4;;,''r)c:|j|j Sr+r,rls r(__neg__zInteger.__neg__r{r)c:|j|jSr+r,rls r( __invert__zInteger.__invert__r{r)cXt|j|}|r|j|S|Sr+)roundr.r-r%nrs r( __round__zInteger.__round__s( $++q ! ::a= Hr)c@tj|jSr+)mathfloorr.rls r( __floor__zInteger.__floor__szz$++&&r)c@tj|jSr+)rceilr.rls r(__ceil__zInteger.__ceil__syy%%r)c^|jtj|jSr+)r-rtruncr.rls r( __trunc__zInteger.__trunc__szz$**T[[122r)c |j|kSr+r.r/s r(__lt__zInteger.__lt__{{U""r)c |j|kSr+rr/s r(__le__zInteger.__le__{{e##r)c |j|k(Sr+rr/s r(__eq__zInteger.__eq__rr)c |j|k7Sr+rr/s r(__ne__zInteger.__ne__rr)c |j|kDSr+rr/s r(__gt__zInteger.__gt__rr)c |j|k\Sr+rr/s r(__ge__zInteger.__ge__rr)c t|S#t$r? |j|cYS#t$r }t j d|d|d}~wwxYwwxYw)Nz Can't coerce z into integer: )rk ValueErrorr!KeyErrorr PyAsn1Errorr%r&excs r(prettyInzInteger.prettyInsa u:   ''.. '';@#F   s( A(A AA  AAch t|j|S#t$rt|cYSwxYwr+)strr!rr/s r( prettyOutzInteger.prettyOuts6 t''./ / u:  s 11c|jSr+)r!rls r(getNamedValueszInteger.getNamedValuessr)r+r)C__name__ __module__ __qualname____doc__r initTagSetTagtagClassUniversaltagFormatSimpletagSetrConstraintsIntersection subtypeSpecr NamedValuesr!rr" getTypeIdtypeIdrr#r0r3r6r8r:r<r>rArCrErGrIrKrMrOrQrWrYr[r]r`rbrfrh__hash__rmrrrvrxrzr}rrrrrrrrrrrrrrr)r(r r si0hS^^%%s':':DAF5*446K'(&&(K * * ,F$< //////00////////;300))66""++H ", ((('&3#$$$#$  r)r ceZdZdZej ej ejejdZ e je jddzZ ejddZe j#Zy)r adCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`int` objects. Keyword Args ------------ value: :class:`int`, :class:`str` or |ASN.1| object Python :class:`int` or :class:`str` literal or |ASN.1| class instance. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s).Constraints verification for |ASN.1| type occurs automatically on object instantiation. namedValues: :py:class:`~pyasn1.type.namedval.NamedValues` Object representing non-default symbolic aliases for numbers Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class RoundResult(Boolean): ''' ASN.1 specification: RoundResult ::= BOOLEAN ok RoundResult ::= TRUE ko RoundResult ::= FALSE ''' ok = RoundResult(True) ko = RoundResult(False) r)Falser)TruerN)rrrrr rrrrrr rrSingleValueConstraintr rr!rrrr)r(r r s*\S^^%%s':':DAF%%(H (H(HA(NNK'(&&|[AK   Fr)r c eZdZdxZZdZdZy) SizedIntegerNcX||_t||jz d|_|SNr) bitLengthmax bit_lengthleadingZeroBits)r%rs r( setBitLengthzSizedInteger.setBitLengthIs)""9t/@#@!D r)cp|j|j|j|jSr+)rrrrls r(__len__zSizedInteger.__len__Ns+ >> !   doo/ 0~~r))rrrrrrrrr)r(rrFs"&&I r)rceZdZdZej ej ejejdZ e jZ e jZej"j%ZexZZefdZdZdZdZdZdZd Zd Zd Zd Z d Z!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.e/d dZ0e/d dZ1e/d!dZ2dZ3y)"raCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type both Python :class:`tuple` (as a tuple of bits) and :class:`int` objects. Keyword Args ------------ value: :class:`int`, :class:`str` or |ASN.1| object Python :class:`int` or :class:`str` literal representing binary or hexadecimal number or sequence of integer bits or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. namedValues: :py:class:`~pyasn1.type.namedval.NamedValues` Object representing non-default symbolic aliases for numbers binValue: :py:class:`str` Binary string initializer to use instead of the *value*. Example: '10110011'. hexValue: :py:class:`str` Hexadecimal string initializer to use instead of the *value*. Example: 'DEADBEEF'. Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class Rights(BitString): ''' ASN.1 specification: Rights ::= BIT STRING { user-read(0), user-write(1), group-read(2), group-write(3), other-read(4), other-write(5) } group1 Rights ::= { group-read, group-write } group2 Rights ::= '0011'B group3 Rights ::= '3'H ''' namedValues = NamedValues( ('user-read', 0), ('user-write', 1), ('group-read', 2), ('group-write', 3), ('other-read', 4), ('other-write', 5) ) group1 = Rights(('group-read', 'group-write')) group2 = Rights('0011') group3 = Rights(0x3) c |turH|rF |j|jdd} |j |jdd}|tur_|j tur|j|j d}n/|j tur|j |j d}d|vr|j|d<tjj||fi|y#t$rYwxYw#t$rYwxYw)NbinValueTinternalFormathexValuer!) rfromBinaryStringpopr fromHexStringdefaultBinValuedefaultHexValuer!rr"r#r$s r(r#zBitString.__init__s  G  11&**Z2HY]1^E  ..vzz*/EVZ.[E G ##72--d.B.BSW-X%%W4**4+?+?PT*U  &$($4$4F= ! $$T5;F;'   s""C-"C<- C98C9< DDc"|jSr+)asBinaryrls r(__str__zBitString.__str__s}}r)c|j|}||uxs2|j|k(xr!t|jt|k(Sr+rr.lenr%others r(rzBitString.__eq__s@ e$u}W u 4 WT[[9ISQVZ9WWr)c|j|}|j|k7xs!t|jt|k7Sr+rrs r(rzBitString.__ne__s6 e${{e#Es4;;'73u:'EEr)c|j|}t|jt|kxs2t|jt|k(xr|j|kSr+rrr.rs r(rzBitString.__lt__Q e$4;;#e*,fDKK0@CJ0N0fSWS^S^afSffr)c|j|}t|jt|kxs2t|jt|k(xr|j|kSr+rrs r(rzBitString.__le__Q e$4;;3u:-hT[[1ASZ1O1hTXT_T_chThhr)c|j|}t|jt|kDxs2t|jt|k(xr|j|kDSr+rrs r(rzBitString.__gt__rr)c|j|}t|jt|k\xs2t|jt|k(xr|j|k\Sr+rrs r(rzBitString.__ge__rr)c,t|jSr+rr.rls r(rzBitString.__len__rnr)c 4|jtur@|jt|j t |Dcgc]}|| c}St |j dz }||kDs|dkr td|j ||z z dzScc}w)Nrrzbit index out of range) __class__slicer-rangeindicesrr. IndexError)r%ixlengths r( __getitem__zBitString.__getitem__s ;;% ::qyyT7K0LM1tAwMN N%)F6zQU !9::KKFQJ/14 4 Ns Bc#tKt|j}|r|dz}|j|z dz|ryywNrr)r%rs r(__iter__zBitString.__iter__s9T[[! aKF;;&(A- -s388c*tt|Sr+)reversedtuplerls r( __reversed__zBitString.__reversed__sd $$r)c|j|}|jt|jt |z|zj t |jt |zSr+)rr-rr.rrr/s r(rCzBitString.__add__sZ e$zz,t{{c%j'@5'HIVVWZ[_[f[fWgjmnsjtWtuvvr)c|j|}|jt|t|jz|jzj t|jt|zSr+)rr-rrr.rr/s r(rEzBitString.__radd__s_ e$zz,uDKK0@'@4;;'NO\\]`aealal]mpstypz]z{||r)c|j}|dkDr2|t|jz}||jz}|dz}|dkDr2|j|Sr)r.rr-)r%r& bitStrings r(rKzBitString.__mul__sVKK ai #dkk* *I  $I QJEaizz)$$r)c ||zSr+rr/s r(rMzBitString.__rmul__  e|r)c|jt|j|zjt |j|zSr+)r-rr.rrr%counts r(r>zBitString.__lshift__ s9zz,t{{e';<II#dkkJZ]bJbcddr)c |jt|j|z jt dt |j|z Sr)r-rr.rrrrs r(rAzBitString.__rshift__sDzz,t{{e';<II#aQTUYU`U`QadiQiJjkllr)c,t|jSr+rjrls r(rmzBitString.__int__rnr)c,t|jSr+rprls r(rrzBitString.__float__rsr)c4t|jS)zGet |ASN.1| value as a sequence of 8-bit integers. If |ASN.1| object length is not a multiple of 8, result will be left-padded with zeros. )rasOctetsrls r( asNumberszBitString.asNumberss T]]_%%r)cVtj|jt|S)zGet |ASN.1| value as a sequence of octets. If |ASN.1| object length is not a multiple of 8, result will be left-padded with zeros. )r)rto_bytesr.rrls r(rzBitString.asOctets s  CI>>r)c|jS)z5Get |ASN.1| value as a single integer value. rrls r( asIntegerzBitString.asInteger(s{{r)ct|jdd}dt|jt|z z|zS)z4Get |ASN.1| value as a text string of bits. rN0)binr.r)r% binStrings r(rzBitString.asBinary-s; $QR( c$++&Y789DDr)Ncf t|djt|dz}|Gtt|t|z|zjt|t|z}|s||}|S#t$r)}t j |j d|d}~wwxYw)Create a |ASN.1| object initialized from the hex string. Parameters ---------- value: :class:`str` Text string like 'DEADBEEF' z.fromHexString() error: Nrrrrrrrclsr&rprependrs r(rzBitString.fromHexString3s Z +88UaHE   g&#e*4=l3w<#e*45 JE  Z##cllTW$XY Y Zs'A>> B0$B++B0ch t|xsddjt|}|Gtt|t|z|zjt|t|z}|s||}|S#t$r)}t j |j d|d}~wwxYw)Create a |ASN.1| object initialized from a string of '0' and '1'. Parameters ---------- value: :class:`str` Text string like '1010111' rrz.fromBinaryString() error: Nrrs r(rzBitString.fromBinaryStringLs ] #q1>>s5zJE   g&#e*4=l3w<#e*45 JE  ]##WZ$[\ \ ]s(A?? B1$B,,B1c>ttjt|d|z j t |dz|z }|Gtt|t |z|zj t |t |z}|s||}|S)zCreate a |ASN.1| object initialized from a string. Parameters ---------- value: :class:`bytes` Text string like b'\\x01\\xff' big)rrk from_bytesbytesrr)rr&rrpaddings r(fromOctetStringzBitString.fromOctetStringesS^^E%L%@GKLYYZ]^cZdghZhkrZrs   g&#e*4=l3w<#e*45 JE r)c t|tr|St|trz|stdjdS|ddk(rT|dddk(r|j |dddS|dddk(r|j |dddSt jd ||jr|js|jd Dcgc]}|j}} |Dcgc]}|j|}}t|}d}|D] }|d||z zz}t|j|dzS|jd r|j |d ddS|jdr|j |d ddS|j |dSt|tt fr8|j dj#|D cgc] } | xrdxsdc} dSt|t$r#t|jt'|St|t(r t|St jd|dcc}wcc}w#t$rt jd |wxYwcc} w)Nr'z'BrTrz'HzBad BIT STRING value notation ,zunknown bit name(s) in 0xr0b1rz Bad BitString initializer type ') isinstancerrrrrrrr!isdigitsplitstriprr startswithrlistjoinrrrk) r%r&rnamesname bitPositionsrightmostPositionnumber bitPositionbs r(rzBitString.prettyInzs e\ *L s ##A33A66qT!:&00qT0RR23Z5(--eAbk$-OO++>CE!!%--/,1KK,<=q==TGL#MtD$4$4T$:#ML#M %( $5!#/EKa$5 $CDDFE$F+889JQ9NOO!!$'))%)D)II!!$',,U12Yt,LL,,U4,HH t} -((E1Rq!)2Bs2B1R)Sdh(i i y )&33CJ? ? s #& &##;@B I>$NT++5,RSST*2Ss* I%I)I?IJ I"I?)FN)FNr)4rrrrr rrrrrrrrr rr!rr"rrrrrr#rrrrrrrrrrrrCrErKrMr>rArmrrr rr r classmethodrrr"rrr)r(rrUsC>DS^^%%s':':DAF5*446K'(&&(K * * ,F(//Oo$<6XFgigi  5. % w}%em "&? E 00(8r)rczeZdZdZej ej ejejdZ e jZ e jjZexZZdZefdZdZdZdZdZd Zd Zdd Zed Zed ZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*y)raCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type :class:`bytes`. When used in Unicode context, |ASN.1| type assumes "|encoding|" serialisation. Keyword Args ------------ value: :class:`unicode`, :class:`str`, :class:`bytes` or |ASN.1| object :class:`bytes`, alternatively :class:`str` representing character string to be serialised into octets (note `encoding` parameter) or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. encoding: :py:class:`str` Unicode codec ID to encode/decode :class:`str` the payload when |ASN.1| object is used in text string context. binValue: :py:class:`str` Binary string initializer to use instead of the *value*. Example: '10110011'. hexValue: :py:class:`str` Hexadecimal string initializer to use instead of the *value*. Example: 'DEADBEEF'. Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class Icon(OctetString): ''' ASN.1 specification: Icon ::= OCTET STRING icon1 Icon ::= '001100010011001000110011'B icon2 Icon ::= '313233'H ''' icon1 = Icon.fromBinaryString('001100010011001000110011') icon2 = Icon.fromHexString('313233') rz iso-8859-1c |rJ|turB |j|jd} |j |jd}|tur[|j tur|j|j }n-|j tur|j |j }d|vr|j|d<tjj||fi|y#t$rYwxYw#t$rYwxYw)Nrrencoding) rrrrrrrr<rr"r#r$s r(r#zOctetString.__init__s  11&**Z2HIE  ..vzz*/EFE G ##72--d.B.BC%%W4**4+?+?@ V #!%F:  $$T5;F;'   s" C% C4% C10C14 D?Dc t|tr|St|tr |j|jSt|tr|jSt|tjr|jt|St|ttfr|jt|St|S#t $r,}t jd|d|jd|d}~wwxYw)NzCan't encode string '' with 'z' codec)r+r rencoder<UnicodeEncodeErrorrPyAsn1UnicodeEncodeErrorrrrr"rrr0rs r(rzOctetString.prettyIns eU #L s # ||DMM22{ +>># # t22 3==U, , t} -==u. .< & 44$dmm569 sC D'C>>Dc  |jj|jS#t$rM}t j d|jd|jd|j jd|d}~wwxYw)NzCan't decode string 'r>z ' codec at 'r$)r.decoder<UnicodeDecodeErrorrPyAsn1UnicodeDecodeErrorrr)r%rs r(rzOctetString.__str__5se ;;%%dmm4 4! 00++t}} NN33569  s$' A=AA88A=c,t|jSr+r r.rls r( __bytes__zOctetString.__bytes__@rsr)c,t|jSr+rGrls r(rzOctetString.asOctetsCrsr)c,t|jSr+)rr.rls r(r zOctetString.asNumbersFrsr)c|Sr+rr/s r(rzOctetString.prettyOut[s r)c|j|j}||jur|S|j}|D])}|dks|dkDsddjd|DzcStj |S)N ~r'r)c3&K|] }d|z yw)z%.2xNr).0rs r( z*OctetString.prettyPrint..js&Cavz&Cs)rr.r r1rr)r%scoper&numbersrs r( prettyPrintzOctetString.prettyPrint^szt{{+  #L.." -A2vSbgg&C7&CDDD - &&t, ,r)cd}d}g}|D]O}|r|dz}nd}|j|d}|dvr t|}ntjd||||zz}Q|j|t |S)rrrr)rr*z$Non-binary OCTET STRING initializer )appendrkrrr )r&bitNobytervs r(rzOctetString.fromBinaryStringos  A JF''@AC AJ D  Qxr)cg}g}|D]'}|r!|jt||zdd}&|})|r|jt|dzdt|S)rrNr)rWrkr )r&rprZs r(rzOctetString.fromHexStringse   AQUB(   HHSS"% &Qxr)c,t|jSr+rrls r(rzOctetString.__len__rnr)c|jtur|j|j|S|j|Sr+rrr-r.r%rs r(rzOctetString.__getitem__3 ;;% ::dkk!n- -;;q> !r)c,t|jSr+iterr.rls r(rzOctetString.__iter__DKK  r)c||jvSr+rr/s r( __contains__zOctetString.__contains__ ##r)c\|j|j|j|zSr+)r-r.rr/s r(rCzOctetString.__add__s#zz$++ e(<<==r)c\|j|j||jzSr+)r-rr.r/s r(rEzOctetString.__radd__s#zz$--.<==r)c>|j|j|zSr+r,r/s r(rKzOctetString.__mul__r1r)c ||zSr+rr/s r(rMzOctetString.__rmul__rr)c,t|jSr+rjrls r(rmzOctetString.__int__rnr)c,t|jSr+rprls r(rrzOctetString.__float__rsr)c,t|jSr+)rr.rls r(rzOctetString.__reversed__s $$r)Nr)+rrrrr rrrrrrrrrr"rrrrrr<r#rrrHrr rrT staticmethodrrrrrrgrCrErKrMrmrrrrr)r(rrs8xS^^%%s':':DAF5*446K * * ,F(//OoH$<6 2 """*-"<. " !$>>/ "%r)rceZdZdZej ej ejejdZ e je jdzZ e jZdZy)raiCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`str` objects (always empty). Keyword Args ------------ value: :class:`str` or |ASN.1| object Python empty :class:`str` literal or any object that evaluates to :obj:`False` If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class Ack(Null): ''' ASN.1 specification: Ack ::= NULL ''' ack = Ack('') r)c |r|Sy)Nr)rr/s r(rz Null.prettyIns Lr)N)rrrrr rrrrrrrrrrrrrr)r(rrsmHS^^%%s':':DAF)),LJ,L,LS,QQK " " $Fr)rceZdZdZej ej ejejdZ e jZ e jjZdZdZdZdZdZdZd Zd Zd Zd Zd Zy)ra5Create |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`tuple` objects (tuple of non-negative integers). Keyword Args ------------ value: :class:`tuple`, :class:`str` or |ASN.1| object Python sequence of :class:`int` or :class:`str` literal or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class ID(ObjectIdentifier): ''' ASN.1 specification: ID ::= OBJECT IDENTIFIER id-edims ID ::= { joint-iso-itu-t mhs-motif(6) edims(7) } id-bp ID ::= { id-edims 11 } ''' id_edims = ID('2.6.7') id_bp = id_edims + (11,) c>|j|j|zSr+r,rs r(rCzObjectIdentifier.__add__8r1r)c>|j||jzSr+r,rs r(rEzObjectIdentifier.__radd__;r4r)c|jSr+rrls r(asTuplezObjectIdentifier.asTuple> {{r)c,t|jSr+rrls r(rzObjectIdentifier.__len__Crnr)c|jtur|j|j|S|j|Sr+r_r`s r(rzObjectIdentifier.__getitem__Frar)c,t|jSr+rcrls r(rzObjectIdentifier.__iter__Lrer)c||jvSr+rr/s r(rgzObjectIdentifier.__contains__Orhr)c8|jj|Sr+r.indexr%suboids r(rzObjectIdentifier.indexR{{  ((r)cbt|}|t|kr|jd||d|k(ryy)arIndicate if this |ASN.1| object is a prefix of other |ASN.1| object. Parameters ---------- other: |ASN.1| object |ASN.1| object Returns ------- : :class:`bool` :obj:`True` if this |ASN.1| object is a parent (e.g. prefix) of the other |ASN.1| object or :obj:`False` otherwise. NTFrr%rls r( isPrefixOfzObjectIdentifier.isPrefixOfUs6 I E ?{{2A%)+r)c ft|tr t|St|trd|vrGt j d|d|j jdtjd t|jdDcgc]}|st|c}S t|Dcgc]}|dk\s t|c}}t|t|k(r|St j d|d|j jcc}w#t$r7}t j d|d|j jd|d}~wwxYwcc}w#ttf$r7}t j d|d|j jd|d}~wwxYw)N-zMalformed Object ID  at : r.r)r+rrrrrrrsysexc_infor-rkr TypeErrorrr%r&subOidr tupleOfIntss r(rzObjectIdentifier.prettyInisf e- .<  s #e|'':?AXAXZ]ZfZfZhijZkl  C8HSfFc&kSTT  5 PFaKV PQK { s5z ) %I`I` abb#T '':?AXAXZ]^  !QI& ##6;T^^=T=TVYZ  `8D"D D%D"- E*6 E% E%E*D"" E"+2EE"%E**F092F++F0c\dj|Dcgc] }t|c}Scc}wNrr1rr%r&rs r(rzObjectIdentifier.prettyOut#xx/AQ/00/)Nrrrrr rrrrrrrrrr"rrrCrEryrrrrgrrrrrr)r(rrs(XS^^%%s':':DAF5*446K * * ,F//  " !$)(c:1r)rceZdZdZej ej ejejdZ e jZ e jjZdZdZdZdZdZdZd Zd Zd Zd Zd Zy) RelativeOIDa[Create |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`tuple` objects (tuple of non-negative integers). Keyword Args ------------ value: :class:`tuple`, :class:`str` or |ASN.1| object Python sequence of :class:`int` or :class:`str` literal or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class RelOID(RelativeOID): ''' ASN.1 specification: id-pad-null RELATIVE-OID ::= { 0 } id-pad-once RELATIVE-OID ::= { 5 6 } id-pad-twice RELATIVE-OID ::= { 5 6 7 } ''' id_pad_null = RelOID('0') id_pad_once = RelOID('5.6') id_pad_twice = id_pad_once + (7,) c>|j|j|zSr+r,rs r(rCzRelativeOID.__add__r1r)c>|j||jzSr+r,rs r(rEzRelativeOID.__radd__r4r)c|jSr+rrls r(ryzRelativeOID.asTuplerzr)c,t|jSr+rrls r(rzRelativeOID.__len__rnr)c|jtur|j|j|S|j|Sr+r_r`s r(rzRelativeOID.__getitem__rar)c,t|jSr+rcrls r(rzRelativeOID.__iter__rer)c||jvSr+rr/s r(rgzRelativeOID.__contains__rhr)c8|jj|Sr+rrs r(rzRelativeOID.indexrr)cbt|}|t|kr|jd||d|k(ryy)apIndicate if this |ASN.1| object is a prefix of other |ASN.1| object. Parameters ---------- other: |ASN.1| object |ASN.1| object Returns ------- : :class:`bool` :obj:`True` if this |ASN.1| object is a parent (e.g. prefix) of the other |ASN.1| object or :obj:`False` otherwise. NTFrrs r(rzRelativeOID.isPrefixOfs6 I E ?{{2A%)+r)c ft|tr t|St|trd|vrGt j d|d|j jdtjd t|jdDcgc]}|st|c}S t|Dcgc]}|dk\s t|c}}t|t|k(r|St j d|d|j jcc}w#t$r7}t j d|d|j jd|d}~wwxYwcc}w#ttf$r7}t j d|d|j jd|d}~wwxYw)NrzMalformed RELATIVE-OID rrrrr)r+rrrrrrrrrr-rkrrrrs r(rzRelativeOID.prettyInse e[ )<  s #e|''=BDNND[D[]`]i]i]klm]no  C8HSfFc&kSTT  5 PFaKV PQK { s5z ) UDNNLcLc dee#T ''=BDNND[D[]`a  !QI& ##9>@W@WY\]  rc\dj|Dcgc] }t|c}Scc}wrrrs r(rzRelativeOID.prettyOutrrNrrr)r(rrs HS^^%%s':':DAF5*446K * * ,F//  " !$)$f:1r)rcreZdZdZdZ edZedZeefZe je je je jdZej"Zej(j+ZedZdZd/d Zed Zed Zed Zd ZdZ dZ!dZ"dZ#dZ$dZ%dZ&d0dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1d/d Z2d!Z3d"Z4d#Z5d$Z6d%Z7d&Z8d'Z9d(Z:d)Z;d*Zd,Z?d-Z@d.ZAy#e $r dxZZdZYwxYw)1rabCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`float` objects. Additionally, |ASN.1| objects behave like a :class:`tuple` in which case its elements are mantissa, base and exponent. Keyword Args ------------ value: :class:`tuple`, :class:`float` or |ASN.1| object Python sequence of :class:`int` (representing mantissa, base and exponent) or :class:`float` instance or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class Pi(Real): ''' ASN.1 specification: Pi ::= REAL pi Pi ::= { mantissa 314159, base 10, exponent -5 } ''' pi = Pi((314159, 10, -5)) Ninfz-infr cV|\}}}|r|dzdk(r|dz}|dz }|r |dzdk(r|||fS)N rrr)r&mr8es r(__normalizeBase10zReal.__normalizeBase10QsH1aAFaK GA FAAFaK!Qwr)ct|trt|dk(rt|dttfr&t|dtrt|dtst j d|t|dtr"|jr|d|jvr|dS|ddvrt j d|d|ddk(r|j|}|St|tr|j|ddfSt|tst|tr~t|tr t |}|jr||jvr|Sd}t||k7r|dz}|dz}t||k7r|jt|d|fSt|tr t|St j d |#t$rt j d |wxYw) NrrrrzLame Real value syntax: )rrz Prohibited base for Real value: rzBad real value syntax: ) r+rrrkrqrr_inf_Real__normalizeBase10rrr)r%r&rs r(rz Real.prettyInYs eU #E auQx#u6"58S1"58S1''(OPP58U+II%(dii"7QxQxw&''s = G"G?cV |jt|S#t$rYywxYw)Nz )rrq OverflowError)r%rRs r(rTzReal.prettyPrints, >>%+. .  s  ((c4|j|jk(S)zIndicate PLUS-INFINITY object value Returns ------- : :class:`bool` :obj:`True` if calling object represents plus infinity or :obj:`False` otherwise. )r._plusInfrls r( isPlusInfzReal.isPlusInfs{{dmm++r)c4|j|jk(S)zIndicate MINUS-INFINITY object value Returns ------- : :class:`bool` :obj:`True` if calling object represents minus infinity or :obj:`False` otherwise. )r. _minusInfrls r( isMinusInfzReal.isMinusInfs{{dnn,,r)c2|j|jvSr+)r.rrls r(isInfz Real.isInfs{{dii''r)c<|jt||zSr+r-rqr/s r(rCz Real.__add__zz%+-..r)c ||zSr+rr/s r(rEz Real.__radd__rr)c<|jt||zSr+rr/s r(rKz Real.__mul__rr)c ||zSr+rr/s r(rMz Real.__rmul__rr)c<|jt||z Sr+rr/s r(rGz Real.__sub__rr)c<|j|t|z Sr+rr/s r(rIz Real.__rsub__zz%%+-..r)c<|jt||zSr+rr/s r(rOz Real.__mod__rr)c<|j|t|zSr+rr/s r(rQz Real.__rmod__rr)cL|jtt|||Sr+r-rTrqrUs r(rWz Real.__pow__szz#eDk5&9::r)cJ|jt|t|Sr+rr/s r(rYz Real.__rpow__szz#eU4[122r)c<|jt||z Sr+rr/s r(r`zReal.__truediv__rr)c<|j|t|z Sr+rr/s r(rbzReal.__rtruediv__rr)c<|jt||zSr+rr/s r(rfzReal.__divmod__szz%+.//r)c<|j|t|zSr+rr/s r(rhzReal.__rdivmod__szz%5;.//r)c*tt|Sr+)rkrqrls r(rmz Real.__int__s5;r)c|j|jvr |jSt|jdt|jd|jdzS)Nrrr)r.rrqrTrls r(rrzReal.__float__sP ;;$)) #;;  AT[[^T[[^!DD r)cH|jtt|Sr+)r-rurqrls r(rvz Real.__abs__szz#eDk*++r)c8|jt|Sr+rrls r(rzz Real.__pos__zz5;,''r)c8|jt| Sr+rrls r(r}z Real.__neg__rr)cVtt||}|r|j|S|Sr+)rrqr-rs r(rzReal.__round__s( %+q ! ::a= Hr)c\|jtjt|Sr+)r-rrrqrls r(rzReal.__floor__zz$**U4[122r)c\|jtjt|Sr+)r-rrrqrls r(rz Real.__ceil__szz$))E$K011r)c\|jtjt|Sr+)r-rrrqrls r(rzReal.__trunc__rr)ct||kSr+rqr/s r(rz Real.__lt__T{U""r)ct||kSr+rr/s r(rz Real.__le__T{e##r)ct||k(Sr+rr/s r(rz Real.__eq__rr)ct||k7Sr+rr/s r(rz Real.__ne__rr)ct||kDSr+rr/s r(rz Real.__gt__rr)ct||k\Sr+rr/s r(rz Real.__ge__rr)c*tt|Sr+)boolrqrls r(__bool__z Real.__bool__sE$K  r)cz|j|jvrtjd|j|S)Nz Invalid infinite value operation)r.rrrr%idxs r(rzReal.__getitem__ s3 ;;$)) ###$FG G;;s# #r)c|jSr+)rrls r(isPlusInfinityzReal.isPlusInfinity ~~r)c|jSr+)rrls r(isMinusInfinityzReal.isMinusInfinitys r)c|jSr+)rrls r( isInfinityzReal.isInfinitys zzr)rr+)Brrrr binEncBaserqrrrrr rrrrrrrrrr"rrrprrrTpropertyrrrrCrErKrMrGrIrOrQrWrYr`rbrfrhrmrrrvrzr}rrrrrrrrrrrrrrrrrr)r(rr s)TJ<&M "S^^%%s':':DAF5*446K * * ,F& P  , , - -((//////;3//00 ,((323#$$$#$!""++H$w ##9sD'' D65D6rceZdZdZej ej ejejdZ e jZ e jZej"Zy)raCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type Python :class:`int` objects. Keyword Args ------------ value: :class:`int`, :class:`str` or |ASN.1| object Python :class:`int` or :class:`str` literal or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. namedValues: :py:class:`~pyasn1.type.namedval.NamedValues` Object representing non-default symbolic aliases for numbers Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class RadioButton(Enumerated): ''' ASN.1 specification: RadioButton ::= ENUMERATED { button1(0), button2(1), button3(2) } selected-by-default RadioButton ::= button1 ''' namedValues = NamedValues( ('button1', 0), ('button2', 1), ('button3', 2) ) selected_by_default = RadioButton('button1') rN)rrrrr rrrrrrrrr rrr rr!rr)r(rrsl/fS^^%%s':':DAF5*446K   F'(&&(Kr)rceZdZdZdZdZdZdZdZdZ dd Z d Z dd Z d Z d ZdZedfdZedddfdZedZedZdZdZddZddZedZedZy)ra<Create |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.ConstructedAsn1Type`, its objects are mutable and duck-type Python :class:`list` objects. Keyword Args ------------ componentType : :py:class:`~pyasn1.type.base.PyAsn1Item` derivative A pyasn1 object representing ASN.1 type allowed within |ASN.1| type tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type can only occur on explicit `.isInconsistent` call. Examples -------- .. code-block:: python class LotteryDraw(SequenceOf): # SetOf is similar ''' ASN.1 specification: LotteryDraw ::= SEQUENCE OF INTEGER ''' componentType = Integer() lotteryDraw = LotteryDraw() lotteryDraw.extend([123, 456, 789]) c|r2td|D]#\}}||vrtjd||d<%t|_t j j|fi|y)N) componentTyperrz*Conflicting positional and keyword params!r)ziprrr_componentValuesrConstructedAsn1Typer#)r%argsr'keyr&s r(r#zSequenceOfAndSetOfBase.__init__sk !#2379 0 U&=++,XYY*/'  0 !(   ))$9&9r)cr |j|S#tj$r}t|d}~wwxYwr+)getComponentByPositionrrrr%rrs r(rz"SequenceOfAndSetOfBase.__getitem__s8 "..s3 3   "S/ ! "s6 16cv |j||y#tj$r}t|d}~wwxYwr+)setComponentByPositionrrrr%rr&rs r( __setitem__z"SequenceOfAndSetOfBase.__setitem__s7 "  ' 'U 3   "S/ ! "s8 38cb|jturd}nt|j}|||<yr)rrr)r%r&poss r(rWzSequenceOfAndSetOfBase.appends0  G +Cd++,CS r)cft|jjj|Sr+)r0rvaluesrr/s r(rzSequenceOfAndSetOfBase.counts'D))002399%@@r)ch|D]}|j||jturi|_yyr+)rWrr)r%rr&s r(extendzSequenceOfAndSetOfBase.extends: E KK    G +$&D ! ,r)Nc| t|}t|jj\}}t |} ||j |||S#t j$r}t|d}~wwxYwr+) rrritemsr0rrrr)r%r&startstoprrrs r(rzSequenceOfAndSetOfBase.indexsu <t9Dt44::<=f "6<<ud;< <   "S/ ! "sAA6& A11A6c8|jjyr+)rreverserls r(rzSequenceOfAndSetOfBase.reverses %%'r)c ~ttt|jj |||_y)N)rr)dict enumeratesortedrr)r%rrs r(sortzSequenceOfAndSetOfBase.sorts4 $ fT2299;!$g7 8!9r)cp|jtus |jsyt|jdzS)Nrr)rrrrls r(rzSequenceOfAndSetOfBase.__len__s1  G +43H3H4(()A--r)c#fKtdt|D]}|j|ywr)rrrrs r(rzSequenceOfAndSetOfBase.__iter__s1CI& 3C--c2 2 3s/1c|jjD]k\}}|tust|tj r#|j ||j|L|j ||jmyNcloneValueFlag)rr rr+rrrr-r%myClonerrcomponentValues r(_cloneComponentValuesz,SequenceOfAndSetOfBase._cloneComponentValuess{#'#8#8#>#>#@ P CW,nd.F.FG22^111P2238L8L8NO Pr)Tct|trAttt |}||Dcgc]}|j |||c}S|dkr(t ||z}|dkrt jd |j|}|tus |jr|S|Scc}w#tt jf$r)|s|cYS|j||j|}Y^wxYw)a2Return |ASN.1| type component value by position. Equivalent to Python sequence subscription operation (e.g. `[]`). Parameters ---------- idx : :class:`int` Component index (zero-based). Must either refer to an existing component or to N+1 component (if *componentType* is set). In the latter case a new component type gets instantiated and appended to the |ASN.1| sequence. Keyword Args ------------ default: :class:`object` If set and requested component is a schema object, return the `default` object instead of the requested component. instantiate: :class:`bool` If :obj:`True` (default), inner component will be automatically instantiated. If :obj:`False` either existing component or the :class:`NoValue` object will be returned. Returns ------- : :py:class:`~pyasn1.type.base.PyAsn1Item` Instantiate |ASN.1| component type or return existing component value Examples -------- .. code-block:: python # can also be SetOf class MySequenceOf(SequenceOf): componentType = OctetString() s = MySequenceOf() # returns component #0 with `.isValue` property False s.getComponentByPosition(0) # returns None s.getComponentByPosition(0, default=None) s.clear() # returns noValue s.getComponentByPosition(0, instantiate=False) # sets component #0 to OctetString() ASN.1 schema # object and returns it s.getComponentByPosition(0, instantiate=True) # sets component #0 to ASN.1 value object s.setComponentByPosition(0, 'ABCD') # returns OctetString('ABCD') value object s.getComponentByPosition(0, instantiate=False) s.clear() # returns noValue s.getComponentByPosition(0, instantiate=False) r&SequenceOf/SetOf index is out of range) r+rrrrrrrrrrrisValue)r%rdefault instantiatersubidxrs r(rz-SequenceOfAndSetOfBase.getComponentByPositionsD c5 !E#d),-G")#,0//M0 0 7d)c/CQw''<>> 8!2237N g !7!7! !N/0%++, 8  ' ' ,!2237N  8sB'B,,C. C.-C.cht|trZttt |}|xr||dxsd}t |D]\}} |j ||z| ||||S|dkr(t ||z}|dkrtjd|j} |jturi} n |j} | j|t} |tur2| | j}n/| tur&tjdt|tjs| -t| tj r| j|}n| tur-t| tj r| j|}ntjd|d|| v|s|rr|j"xr | j$xs | j&} | ||xr||xr|s8| j(t*j(k7rtjd|d| || |<| |_ |S) aAssign |ASN.1| type component by position. Equivalent to Python sequence item assignment operation (e.g. `[]`) or list.append() (when idx == len(self)). Parameters ---------- idx: :class:`int` Component index (zero-based). Must either refer to existing component or to N+1 component. In the latter case a new component type gets instantiated (if *componentType* is set, or given ASN.1 object is taken otherwise) and appended to the |ASN.1| sequence. Keyword Args ------------ value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative A Python value to initialize |ASN.1| component with (if *componentType* is set) or ASN.1 value object to assign to |ASN.1| component. If `value` is not given, schema object will be set as a component. verifyConstraints: :class:`bool` If :obj:`False`, skip constraints validation matchTags: :class:`bool` If :obj:`False`, skip component tags matching matchConstraints: :class:`bool` If :obj:`False`, skip component constraints matching Returns ------- self Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer IndexError When idx > len(self) rr Component type not definedr&zNon-ASN.1 value z! and undefined component type at %Component value is tag-incompatible:  vs )r+rrrrrrrrrrrgetr-rAsn1Itemr"strictConstraintsisSameTypeWith isSuperTypeOfrr)r%rr&verifyConstraints matchTagsmatchConstraintsrstartIdxsubIdxsubValuercomponentValues currentValuesubtypeCheckers r(rz-SequenceOfAndSetOfBase.setComponentByPosition>s@X c5 !E#d),-G273<?7aH$-e$4 1 ++v%x1B/1 1K 7d)c/CQw''<>>**  G + O#33O&**38 G (%++-(''(DEEE4==1)}d.A.AB%++%+8g-|T-@-@A$***7''%*D233 &I9I**1!000!//  "%):)Hy"3"H8HJ!''3::5++ %}677 % / r)cH|j|jjSyr+)rtagMaprls r(componentTagMapz&SequenceOfAndSetOfBase.componentTagMaps%    )%%,, , *r)clt|jDcgc]}|j|c}Scc}wr+)rrrs r( componentsz!SequenceOfAndSetOfBase.componentss:"$"7"78:%%c*: ::s1ci|_|S)zRemove all components and become an empty |ASN.1| value object. Has the same effect on |ASN.1| object as it does on :class:`list` built-in. rrls r(clearzSequenceOfAndSetOfBase.clears !# r)ct|_|SzRemove all components and become a |ASN.1| schema object. See :meth:`isValue` property for more information on the distinction between value and schema objects. )rrrls r(resetzSequenceOfAndSetOfBase.resets !( r)c|dz }|jjdz}|js|St|D];\}}|d|zz }|tur|j |dz }(||j |z }=|S)Nr:  z)rrr!rrrrTr%rRrepresentationrrs r(rTz"SequenceOfAndSetOfBase.prettyPrints  0058||! !#,T? D C cEk )N')&&2)+."<"  { rE })rrrrprettyPrintType)r%rRrGs r(rMz&SequenceOfAndSetOfBase.prettyPrintTypesv  +/;;8O8OP    ) cEk )N d00@@G GN$seai'883>>r)c|jturyt|jt|k7ry|jjD]}|tus |jryy)arIndicate that |ASN.1| object represents ASN.1 value. If *isValue* is :obj:`False` then this object represents just ASN.1 schema. If *isValue* is :obj:`True` then, in addition to its ASN.1 schema features, this object can also be used like a Python built-in object (e.g. :class:`int`, :class:`str`, :class:`dict` etc.). Returns ------- : :class:`bool` :obj:`False` if object represents just ASN.1 schema. :obj:`True` if object represents ASN.1 schema and can be used as a normal value. Note ---- There is an important distinction between PyASN1 schema and value objects. The PyASN1 schema objects can only participate in ASN.1 schema-related operations (e.g. defining or testing the structure of the data). Most obvious uses of ASN.1 schema is to guide serialisation codecs whilst encoding/decoding serialised ASN.1 contents. The PyASN1 value objects can **additionally** participate in many operations involving regular Python objects (e.g. arithmetic, comprehension etc). FT)rrrrr!r%rs r(r!zSequenceOfAndSetOfBase.isValuese6  G + t$$ %T 2"33::< N(0F0F r)c4|jtus |jsy|jturyi}|jj D]\}}|tur|||< |j|y#t j $r }|cYd}~Sd}~wwxYwaRun necessary checks to ensure |ASN.1| object consistency. Default action is to verify |ASN.1| object against constraints imposed by `subtypeSpec`. Raises ------ :py:class:`~pyasn1.error.PyAsn1tError` on any inconsistencies found FTN)rrrrr rr)r%mappingrr&rs r(isInconsistentz%SequenceOfAndSetOfBase.isInconsistent s    (0@0@  G +//557 !JC GCL  !    W %    J s&A88B B BB)rNNFr)rrrrr#rrrWrr rrrrrrrrrrr:r<r?rBrTrMr!rSrr)r(rrcs!D :""A' "(9 . 3P3:t[z1815)-04m^--::"?$$L  r)rceZdZejZej ejejejdZ dZ e jZejZy)rrNrrrrrr rrrtagFormatConstructedrrrrrrrrr)r(rr-f$,,G S^^%%s'?'?FF M 5*446K$ - - /Fr)rceZdZejZej ejejejdZ dZ e jZejZy)rNrVrr)r(rrDrXr)rc eZdZdZej ZGddeZdZ dZ dZ dZ dZ d Zd Zd Zd Zd ZdZdZedZdZedfdZedddfdZedfdZedddfdZedZedZddZddZ dZ!dZ"dZ#y) raCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.ConstructedAsn1Type`, its objects are mutable and duck-type Python :class:`dict` objects. Keyword Args ------------ componentType: :py:class:`~pyasn1.type.namedtype.NamedType` Object holding named ASN.1 types allowed within this collection tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type can only occur on explicit `.isInconsistent` call. Examples -------- .. code-block:: python class Description(Sequence): # Set is similar ''' ASN.1 specification: Description ::= SEQUENCE { surname IA5String, first-name IA5String OPTIONAL, age INTEGER DEFAULT 40 } ''' componentType = NamedTypes( NamedType('surname', IA5String()), OptionalNamedType('first-name', IA5String()), DefaultedNamedType('age', Integer(40)) ) descr = Description() descr['surname'] = 'Smith' descr['first-name'] = 'John' c@eZdZdZdZdZdZdZdZdZ dZ d Z y ) SequenceAndSetBase.DynamicNamesz9Fields names/positions mapping for component-less objectsc i|_i|_yr+ _keyToIdxMap _idxToKeyMaprls r(r#z(SequenceAndSetBase.DynamicNames.__init__s "D  "D r)c,t|jSr+)rr`rls r(rz'SequenceAndSetBase.DynamicNames.__len__st(() )r)c>||jvxs||jvSr+r_r%items r(rgz,SequenceAndSetBase.DynamicNames.__contains__s#4,,,I8I8I0I Ir)cRfdttjDS)Nc3<K|]}j|ywr+)ra)rPrr%s r(rQz;SequenceAndSetBase.DynamicNames.__iter__..sTsD%%c*Ts)rrrarls`r(rz(SequenceAndSetBase.DynamicNames.__iter__sTeC@Q@Q G((.. G''t(EFF Gs#4cL||jd|z<d|z|j|<y)Nzfield-%dr_rs r(addFieldz(SequenceAndSetBase.DynamicNames.addFields,25D  j3. /%/#%5D  c "r)N) rrrrr#rrgrrrjrnrprr)r( DynamicNamesr]s1G # * J U / F G 6r)rqc tjj|fi|t|j|_|j rg|_n t|_|j xs|j|_ yr+) rrr#rr_componentTypeLenrrrq _dynamicNames)r%r's r(r#zSequenceAndSetBase.__init__sc   ))$9&9!$T%7%7!8  ! !$&D !$+D !!33Jt7H7H7Jr)ct|tr |j|S |j |S#tj$r}t |d}~wwxYw#tj$r}t|d}~wwxYwr+)r+rgetComponentByNamerrrrrrs r(rzSequenceAndSetBase.__getitem__s{ c3  $..s33 &22377 $$ $sm# $$$ & o% &s,5AA AAA>. A99A>c t|tr |j||y |j ||y#tj$r}t |d}~wwxYw#tj$r}t|d}~wwxYwr+)r+rsetComponentByNamerrrrrrs r(rzSequenceAndSetBase.__setitem__sy c3  $''U3 &++C7 $$ $sm# $$$ & o% &s,9AA AAB2 A==BcR|jr||jvS||jvSr+)rsrrtr%rs r(rgzSequenceAndSetBase.__contains__s-  ! !$,,, ,$,,, ,r)c,t|jSr+)rrrls r(rzSequenceAndSetBase.__len__s4(())r)cHt|jxs |jSr+)rdrrtrls r(rzSequenceAndSetBase.__iter__sD&&<$*<*<==r)c#|Kt|jxst|jD] }|| ywr+)rrsrrtrs r(rzSequenceAndSetBase.valuess9//J3t7I7I3JK Cs)O s:<ct|Sr+)rdrls r(keyszSequenceAndSetBase.keyss Dzr)c#Kt|jxst|jD]E}|jr!|j|j ||f0|j|||fGywr+)rrsrrtrr3rs r(r zSequenceAndSetBase.itemsss//J3t7I7I3JK 9C%%((-22DI==((-tCy88  9sA6A8c@|D] \}}|||< |D] }||||< yr+r)r% iterValue mappingValuekrZs r(updatezSequenceAndSetBase.updates: DAqDG  &A"1oDG &r)c>g|_|j|_|S)zRemove all components and become an empty |ASN.1| value object. Has the same effect on |ASN.1| object as it does on :class:`dict` built-in. )rrqrtrls r(r?zSequenceAndSetBase.clear s" !#!..0 r)cFt|_|j|_|SrA)rrrqrtrls r(rBzSequenceAndSetBase.reset s" !(!..0 r)c|jSr+r>rls r(r<zSequenceAndSetBase.components s$$$r)c0|jturyt|jD]k\}}|tust|tj r#|j ||j|L|j ||jmyr)rrrr+rrrr-rs r(rz(SequenceAndSetBase._cloneComponentValues s  G + #,T-B-B#C P CW,nd.F.FG22^111P2238L8L8NO Pr)Tc|jr|jj|}n |jj|}|j|||S#t$rt j d|dwxYw)apReturns |ASN.1| type component by name. Equivalent to Python :class:`dict` subscription operation (e.g. `[]`). Parameters ---------- name: :class:`str` |ASN.1| type component name Keyword Args ------------ default: :class:`object` If set and requested component is a schema object, return the `default` object instead of the requested component. instantiate: :class:`bool` If :obj:`True` (default), inner component will be automatically instantiated. If :obj:`False` either existing component or the :class:`NoValue` object will be returned. Returns ------- : :py:class:`~pyasn1.type.base.PyAsn1Item` Instantiate |ASN.1| component type or return existing component value rlrmr"r#)rsrrnrtrrrr)r%r3r"r#rs r(rvz%SequenceAndSetBase.getComponentByName' s8  ! !$$66t!KK}S7I7U7UKVE(''(DEEE4==1#0#B#B3#G .0C0CD,222?E ++,L}OfOfOoOo,oppW,L$J]J]1^$***7''(E H_H_HhHh(hii I1A,>>sC w."&"8"8#B"2"A"A#A"2"@"@&e->-L9&7&L">  ?sJ5K  K ch|jtury|j}|rjt|jD]Q\}}|j s |j r|jsy|j|}|tus |jrQyy|jD]}|tus |jryy)aIndicate that |ASN.1| object represents ASN.1 value. If *isValue* is :obj:`False` then this object represents just ASN.1 schema. If *isValue* is :obj:`True` then, in addition to its ASN.1 schema features, this object can also be used like a Python built-in object (e.g. :class:`int`, :class:`str`, :class:`dict` etc.). Returns ------- : :class:`bool` :obj:`False` if object represents just ASN.1 schema. :obj:`True` if object represents ASN.1 schema and can be used as a normal value. Note ---- There is an important distinction between PyASN1 schema and value objects. The PyASN1 schema objects can only participate in ASN.1 schema-related operations (e.g. defining or testing the structure of the data). Most obvious uses of ASN.1 schema is to guide serialisation codecs whilst encoding/decoding serialised ASN.1 contents. The PyASN1 value objects can **additionally** participate in many operations involving regular Python objects (e.g. arithmetic, comprehension etc). It is sufficient for |ASN.1| objects to have all non-optional and non-defaulted components being value objects to be considered as a value objects as a whole. In other words, even having one or more optional components not turned into value objects, |ASN.1| object is still considered as a value object. Defaulted components are normally value objects by default. FT)rrrr namedTypesr isOptionalr!)r%rrrrs r(r!zSequenceAndSetBase.isValueE sD  G +** )2=3K3K)L !%%#//3C3N3N,, !%!6!6s!;!W,N4J4J  !  #'"7"7 !!W,N4J4J  !r)c`|jtus |jsy|jturyi}t |jD].\}}|tur|jj |}|||<0 |j|y#t j$r }|cYd}~Sd}~wwxYwrQ)rrrrrrjrr)r%rRrr&r3rs r(rSz!SequenceAndSetBase.isInconsistent s    (0@0@  G +#D$9$9: "JC%%77$>u$E" r)c|dz }|jd|jjd}t|jj xs |j D]s\}}|d|zz }|jr"|d|jj|zz }n!|d|jj|zz }|d|j|d}u|dzd|dz zzdzS) NrrIrJrEz"%s"z = rKrL) rrrrrrrrjrtrM)r%rRrGrrs r(rMz"SequenceAndSetBase.prettyPrintType s  +/;;8O8OP"+D,>,>,E,E,G,`4K`K`"a  C cEk )N!!&4+=+=+O+OPS+T"TT&4+=+=+O+OPS+T"TT = =e DN  $seai'883>>r)c|Sr+rrls r(setDefaultComponentsz'SequenceAndSetBase.setDefaultComponents  r)c4|jr |jSyr+)rsrrls r(getComponentTypez#SequenceAndSetBase.getComponentType s  ! !%% % "r)cN|jr|j|jSyr+)rsrr3rs r(rjz$SequenceAndSetBase.getNameByPosition s'  ! !%%c*// / "r)Nr)$rrrrr NamedTypesrobjectrqr#rrrgrrrrr rr?rBrr<rrrvrxrrr!rSrTrMrrrjrr)r(rr[s*Z)I((*M&6v&6RK&"&"- *> 9& %% P07D%ZN.5-1%),0, \3:t\|1815)-04iV77r""H, ? &0r)rceZdZejZej ejejejdZ e jZ ejZej#ZdZdZy)rrcR|jr|jj|Syr+)rgetTagMapNearPositionrs r(getComponentTagMapNearPositionz'Sequence.getComponentTagMapNearPosition s'   %%;;C@ @ r)cV|jr|jj||S|Sr+)rgetPositionNearType)r%rrs r(getComponentPositionNearTypez%Sequence.getComponentPositionNearType s)   %%99&#F FJr)N)rrrrrr rrrrWrrrrrrrrrrrrr)r(rr s| ((G S^^%%s'?'?FF5*446K)I((*M ) ) +FAr)rc0eZdZejZej ejejejdZ e jZ ejZej#Zd dZeddfdZeddddfdZedZy) rrZFc|Sr+r)r% innerFlags r( getComponentzSet.getComponent rr)Tc|j|jj|||}|r"t|tr|j dS|S)a8Returns |ASN.1| type component by ASN.1 tag. Parameters ---------- tagSet : :py:class:`~pyasn1.type.tag.TagSet` Object representing ASN.1 tags to identify one of |ASN.1| object component Keyword Args ------------ default: :class:`object` If set and requested component is a schema object, return the `default` object instead of the requested component. instantiate: :class:`bool` If :obj:`True` (default), inner component will be automatically instantiated. If :obj:`False` either existing component or the :class:`noValue` object will be returned. Returns ------- : :py:class:`~pyasn1.type.base.PyAsn1Item` a pyasn1 object rTr)rrgetPositionByTyper+rr)r%rr"r#rrs r(getComponentByTypezSet.getComponentByType s\644    0 0 85  NC8!...> >" !r)c.|jj|}|rd|jj|}|jr|j |||||S|j |}|j ||||||S|j |||||S)a!Assign |ASN.1| type component by ASN.1 tag. Parameters ---------- tagSet : :py:class:`~pyasn1.type.tag.TagSet` Object representing ASN.1 tags to identify one of |ASN.1| object component Keyword Args ------------ value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative A Python value to initialize |ASN.1| component with (if *componentType* is set) or ASN.1 value object to assign to |ASN.1| component. If `value` is not given, schema object will be set as a component. verifyConstraints : :class:`bool` If :obj:`False`, skip constraints validation matchTags: :class:`bool` If :obj:`False`, skip component tags matching matchConstraints: :class:`bool` If :obj:`False`, skip component constraints matching innerFlag: :class:`bool` If :obj:`True`, search for matching *tagSet* recursively. Returns ------- self r)rrrrrrsetComponentByType) r%rr&r/r0r1rrrs r(rzSet.setComponentByType7 sH  226:  ..@@EM##22 19>N!% ; ;C @ $77E#4iAQ]f8..U-y:J r)cH|jr|jjSyr+)r tagMapUniquerls r(r:zSet.componentTagMapn s"   %%22 2 r)NF)rrrrrr rrrrWrrrrrrrrrrrrrrr:rr)r(rr s ((G S^^%%s'?'?FF )I((*M 5*446K ) ) +F29'+u$"L07-1%),0%* 5n33r)rceZdZdZej ZejZ e je jddZ ejZdZdZdZdZdZdZd Zd Zd Zd Zd ZdZdZdZdZdZ e!dfdZ"e!dddfdZ#e$dZ%e$dZ&ddZ'ddZ(e$dZ)dZ*dZ+y)raCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.ConstructedAsn1Type`, its objects are mutable and duck-type Python :class:`list` objects. Keyword Args ------------ componentType: :py:class:`~pyasn1.type.namedtype.NamedType` Object holding named ASN.1 types allowed within this collection tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type can only occur on explicit `.isInconsistent` call. Examples -------- .. code-block:: python class Afters(Choice): ''' ASN.1 specification: Afters ::= CHOICE { cheese [0] IA5String, dessert [1] IA5String } ''' componentType = NamedTypes( NamedType('cheese', IA5String().subtype( implicitTag=Tag(tagClassContext, tagFormatSimple, 0) ), NamedType('dessert', IA5String().subtype( implicitTag=Tag(tagClassContext, tagFormatSimple, 1) ) ) afters = Afters() afters['cheese'] = 'Mascarpone' rNc^|jr|j|j|k(StSr+r _currentIdxNotImplementedrs r(rz Choice.__eq__ -  (()9)9:eC Cr)c^|jr|j|j|k7StSr+rrs r(rz Choice.__ne__ rr)c^|jr|j|j|kStSr+rrs r(rz Choice.__lt__ -  (()9)9:UB Br)c^|jr|j|j|kStSr+rrs r(rz Choice.__le__ rr)c^|jr|j|j|kDStSr+rrs r(rz Choice.__gt__ rr)c^|jr|j|j|k\StSr+rrs r(rz Choice.__ge__ rr)c,t|jSr+)rrrls r(rzChoice.__bool__ sD))**r)c.|jduxrdxsdS)Nrr)rrls r(rzChoice.__len__ st+16Q6r)cp|jy||j|jjk(SrTrrgetNamerzs r(rgzChoice.__contains__ s6    #d(()9)9:BBDDDr)c#K|jt|j|jjywr+)r StopIterationrrrls r(rzChoice.__iter__ s8    #   !1!12::<>@ @ (s8:c#K|j9|j|jj||jfyywr+rrls r(r z Choice.items sG    '$$T%5%56>>@$tGWGWBXX X (sAA cF|jtjdy)NComponent not chosen)rrrrls r(checkConsistencyzChoice.checkConsistency s%    ###$:; ; $r)cd |j}t|tr |j}n |j}t|t j r#|j||j|y|j||jy#tj$rYywxYwr) rr+reffectiveTagSetrrrrr-rr)r%rr componentrs r(rzChoice._cloneComponentValues s F))+I)V,"22")))T%=%=>**IOO>OJ**69??3DE     sBB/.B/Tctj}|j|j|k7rtj||||S|j|S)Nr)rrrrr)r%rr"r#rs r(rzChoice.getComponentByPosition sZ++    #t'7'73'>--dC:E.G G$$S))r)c|j}tj||||||||_|||k7rt|j|<|S)a Assign |ASN.1| type component by position. Equivalent to Python sequence item assignment operation (e.g. `[]`). Parameters ---------- idx: :class:`int` Component index (zero-based). Must either refer to existing component or to N+1 component. In the latter case a new component type gets instantiated (if *componentType* is set, or given ASN.1 object is taken otherwise) and appended to the |ASN.1| sequence. Keyword Args ------------ value: :class:`object` or :py:class:`~pyasn1.type.base.PyAsn1Item` derivative A Python value to initialize |ASN.1| component with (if *componentType* is set) or ASN.1 value object to assign to |ASN.1| component. Once a new value is set to *idx* component, previous value is dropped. If `value` is not given, schema object will be set as a component. verifyConstraints : :class:`bool` If :obj:`False`, skip constraints validation matchTags: :class:`bool` If :obj:`False`, skip component tags matching matchConstraints: :class:`bool` If :obj:`False`, skip component constraints matching Returns ------- self )rrrrr)r%rr&r/r0r1oldIdxs r(rzChoice.setComponentByPosition sSJ!! ""4e5F Scd  &C-,3D ! !& ) r)cj|jr |jS|j}|jS)zwReturn a :class:`~pyasn1.type.tag.TagSet` object of the currently initialized component or self (if |ASN.1| is tagged).)rrr)r%rs r(rzChoice.effectiveTagSet< s/ ;;;; ))+I,, ,r)c|jrtjj|S|jj Sz"Return a :class:`~pyasn1.type.tagmap.TagMap` object mapping ASN.1 tags to ASN.1 objects contained within callee. )rrr9fgetrrrls r(r9z Choice.tagMapE s0 ;;::??4( (%%22 2r)c|jtjd|j|j}|r!t |t r|j |S|S)zReturn currently assigned component of the |ASN.1| object. Returns ------- : :py:class:`~pyasn1.type.base.PyAsn1Item` a PyASN1 object r)rrrrr+rrr%rcs r(rzChoice.getComponentO sX    ###$:; ;%%d&6&67AZ62~~i00r)c|jtjd|r:|j|j}t |t r|j |S|jj|jS)zReturn the name of currently assigned component of the |ASN.1| object. Returns ------- : :py:class:`str` |ASN.1| component name r) rrrrr+rrrrjrs r(rzChoice.getName` sq    ###$:; ;))$*:*:;a(99Y//%%778H8HI Ir)cz|jy|j|j}|tuxr |jS)a~Indicate that |ASN.1| object represents ASN.1 value. If *isValue* is :obj:`False` then this object represents just ASN.1 schema. If *isValue* is :obj:`True` then, in addition to its ASN.1 schema features, this object can also be used like a Python built-in object (e.g. :class:`int`, :class:`str`, :class:`dict` etc.). Returns ------- : :class:`bool` :obj:`False` if object represents just ASN.1 schema. :obj:`True` if object represents ASN.1 schema and can be used as a normal value. Note ---- There is an important distinction between PyASN1 schema and value objects. The PyASN1 schema objects can only participate in ASN.1 schema-related operations (e.g. defining or testing the structure of the data). Most obvious uses of ASN.1 schema is to guide serialisation codecs whilst encoding/decoding serialised ASN.1 contents. The PyASN1 value objects can **additionally** participate in many operations involving regular Python objects (e.g. arithmetic, comprehension etc). F)rrrr!rOs r(r!zChoice.isValueq s?8    #..t/?/?@W,G1G1GGr)c:d|_tj|Sr+)rrr?rls r(r?z Choice.clear syyr)c|jSr+) minTagSetrls r( getMinTagSetzChoice.getMinTagSet rr)r),rrrrr TagSetrrrrrrValueSizeConstraintrrrrrrrrrrrrrrgrrrr rrrrrrrr9rrr!r?rrr)r(rrt s$+^SZZ\F)I((*M 5*44& &&q!,K ]]_FK      +7E =:AY<F"3:t*1815)-04*X--33"J" H HD r)rceZdZdZej ZejZ e jZ e dZy)raCreate |ASN.1| schema or value object. |ASN.1| class is based on :class:`~pyasn1.type.base.SimpleAsn1Type`, its objects are immutable and duck-type :class:`bytes`. When used in Unicode context, |ASN.1| type assumes "|encoding|" serialisation. Keyword Args ------------ value: :class:`unicode`, :class:`str`, :class:`bytes` or |ASN.1| object :class:`bytes`, alternatively :class:`str` representing character string to be serialised into octets (note `encoding` parameter) or |ASN.1| object. If `value` is not given, schema object will be created. tagSet: :py:class:`~pyasn1.type.tag.TagSet` Object representing non-default ASN.1 tag(s) subtypeSpec: :py:class:`~pyasn1.type.constraint.ConstraintsIntersection` Object representing non-default ASN.1 subtype constraint(s). Constraints verification for |ASN.1| type occurs automatically on object instantiation. encoding: :py:class:`str` Unicode codec ID to encode/decode :class:`str` the payload when |ASN.1| object is used in text string context. binValue: :py:class:`str` Binary string initializer to use instead of the *value*. Example: '10110011'. hexValue: :py:class:`str` Hexadecimal string initializer to use instead of the *value*. Example: 'DEADBEEF'. Raises ------ ~pyasn1.error.ValueConstraintError, ~pyasn1.error.PyAsn1Error On constraint violation or bad initializer. Examples -------- .. code-block:: python class Error(Sequence): ''' ASN.1 specification: Error ::= SEQUENCE { code INTEGER, parameter ANY DEFINED BY code -- Either INTEGER or REAL } ''' componentType=NamedTypes( NamedType('code', Integer()), NamedType('parameter', Any(), openType=OpenType('code', {1: Integer(), 2: Real()})) ) error = Error() error['code'] = 1 error['parameter'] = Integer(1234) c |jS#t$r_tj|j|it j jt j i||_|jcYSwxYwr)_tagMapAttributeErrorr TagMaprr endOfOctetsrls r(r9z Any.tagMap sa <<  !==d#''9DL <<  s A%A65A6N)rrrrr rrrrrrrrrr9rr)r(rr sL@HSZZ\F 5*446K " " $F   r)r)'rrpyasn1rpyasn1.codec.berr pyasn1.compatr pyasn1.typerrrr r r rr__all__r"r r rkrrrrrrrrrrrrrrrrrrr)r(rsq  !"!  ,, ) !c d!!c L=!g=!@ 3 ]##]@ S%$%%S%l1;1hH1t**H1V~1$%%~1BN4  NbB)B)NHT55HT0'0.0 "0.x 011x 0t ! Fy3 y3xgSgT ^ +^ r)