6h\SSKJr SSKrSSKr\R(aSSKJrJr SrSrSr Sr Sr Sr S r S rS rS rS rSrSrSrSrS rSr\R0"S\ S-\-5r\R0"S\ S-\-5r\R0"S\ S-\-5r\R8"S5r\R8"S5r\R8"S5r\R8"S5r \R8"S5r!Sr"Sr#S7Sjr$S8Sjr%S9Sjr&S:S;Sjjr'SS#jr-S?S$jr.S@S%jr/SAS&jr0\1\%\2\(\3\)\4\)\5\-\6\,\7\/\8"S5\00r9S=S'jr:"S(S)\;5r\R8"S+5r?\R8"S,5r@\R8"S-5rASrBSrCSrDSrESrFSrGSCSDS.jjrHSESFS/jjrI"S0S1\15rJ"S2S35rK"S4S55rLS6rMg)G) annotationsN)IterableIteratoriz>Bz>BBz>BHz>BLz>BQcHUS:aUS-U-5$US:a[RUS-S-U5$US:a[RUS-S-U5$US:a[RUS-S-U5$[ RUS-S-U5$) z6Obtain a value encoding the major type and its length.r rlrr)ENCODED_LENGTH_1packENCODED_LENGTH_2ENCODED_LENGTH_3ENCODED_LENGTH_4ENCODED_LENGTH_5) majortypelengths :/usr/lib/python3/dist-packages/mercurial/utils/cborutil.py encodelengthr#Is {$$Y!^f%<== #$$Y!^b%8&AA %$$Y!^b%8&AA * $$Y!^b%8&AA$$Y!^b%8&AAc#J# [[[U55v Uv g7fN)r#MAJOR_TYPE_BYTESTRINGlenvs r"streamencodebytestringr+Ws ,c!f 55 Gs!#c#|# [v UH"n[[[U55v Uv M$ [v g7f)zConvert an iterator of chunks to an indefinite bytestring. Given an input that is iterable and each element in the iterator is representable as bytes, emit an indefinite length bytestring. N)BEGIN_INDEFINITE_BYTESTRINGr#r'r(BREAK)itchunks r"streamencodebytestringfromiterr1\s5 &%0#e*==  Ks:<c## [v Sn[U5nXX!-nU[U5- n[[[U55v Uv X#:aOM;[v g7f)zGiven a large source buffer, emit as an indefinite length bytestring. This is a generator of chunks constituting the encoded CBOR data. rN)r-r(r#r'r.)source chunksizeilr0s r" streamencodeindefinitebytestringr7ksb &% A F A 1=) SZ0#e*== 6   KsAAc## US:dUS:a [S5eUS:a[[U5v g[[[ U5S- 5v g7f)Nllzbig integers not supportedrr) ValueErrorr#MAJOR_TYPE_UINTMAJOR_TYPE_NEGINTabsr)s r"streamencodeintr=sL  A(=$=566Av?A..,c!fqj99sAAc#~# [[[U55v UHn[U5ShvN M gN 7f)z)Encode a known size iterable to an array.N)r#MAJOR_TYPE_ARRAYr( streamencode)r6r5s r"streamencodearrayrAs3 'Q 00 ?"""s /=; =c#h# [v UHn[U5ShvN M [v gN7f)z:Encode an iterator of items to an indefinite length array.N)BEGIN_INDEFINITE_ARRAYr@r.)r/r5s r"streamencodearrayfromiterrDs0 ! ?"" K #s 202c0[U5RU4$r&)type__name__r)s r"_mixedtypesortkeyrHs 7  Q r$c#z# [[[5v [[ U[ S95ShvN gN7f)Nkey)r#MAJOR_TYPE_SEMANTICSEMANTIC_TAG_FINITE_SETrAsortedrH)ss r"streamencodesetrPs, *,C DD /@!ABBBs 1;9;c## [[[U55v [UR 5SS9H+up[ U5ShvN [ U5ShvN M- gNN 7f)zWEncode dictionary to a generator. Does not supporting indefinite length dictionaries. c[US5$Nr)rH)xs r"!streamencodemap..s6G!6Mr$rJN)r#MAJOR_TYPE_MAPr(rNitemsr@)drKvalues r"streamencodemapr[sU ~s1v ..QWWY,MN $$$&&&O$&s$AA+ A' A+A) A+)A+c## [v UH+up[U5ShvN [U5ShvN M- [v gN$N7f)zFGiven an iterable of (key, value), encode to an indefinite length map.N)BEGIN_INDEFINITE_MAPr@r.)r/rKrZs r"streamencodemapfromiterr^sB  $$$&&& K %&sA AA AA A c#&# U(aSOSv g7f)N)bs r"streamencodeboolrds'G#sc## Sv g7f)Nrbr)s r"streamencodenonergs Msc[RUR5nU(d([Hn[X5(dM[Un O U(d[ S[ U5-5eU"U5$)aEncode a value in a streaming manner. Given an input object, encode it to CBOR recursively. Returns a generator of CBOR encoded bytes. There is no guarantee that each emitted chunk fully decodes to a value or sub-value. Encoding is deterministic - unordered collections are sorted. zdo not know how to encode %s)STREAM_ENCODERSget __class__ isinstancer9rF)r*fntys r"r@r@sc   Q[[ )B !Ba$$ $B  " 7$q'ABB a5Lr$c\rSrSrSrSrg)CBORDecodeErrorz"Represents an error decoding CBOR.rbN)rG __module__ __qualname____firstlineno____doc____static_attributes__rbr$r"rprps,r$rpc X$r&rb)rcr5s r"_elementtointegerrxs 4Kr$s>Hs>Ls>QcL[X5nUS- nUS- nU[-nU[:Xa,[X@U5upVnU(a SXgS-[4$SSU[4$U[ :Xa6[X@U5upVnU(aUceSU*S- US-[4$SSU[4$U[ :Xay[X@USS9upXnU(d SSU[4$UbMX-U-[U5::aXU-X-U-nSXgU-S-[4$[U5U- U- U- n SSU [4$SSS[4$U[:Xa [S5eU[:Xa,[X@U5upXnU(a SXS-[4$SSU[4$U[:Xa,[X@U5upXnU(a SXS-[4$SSU[4$U[:Xa[X@U5upZnU(d SSU[4$U [ :XaaX-[U5:a SSS[4$[#XU-5upXpU(d SSU [4$U [:wa [S 5eSXU -S-[$4$[S U -5eU[&:Xa^U[(:Xa SSS[4$U[*:Xa SSS[4$U[,:Xa SSS[4$U[.:Xa SSS[04$[S U-5ee) aCDecode a new CBOR value from a buffer at offset. This function attempts to decode up to one complete CBOR value from ``b`` starting at offset ``offset``. The beginning of a collection (such as an array, map, set, or indefinite length bytestring) counts as a single value. For these special cases, a state flag will indicate that a special value was seen. When called, the function either returns a decoded value or gives a hint as to how many more bytes are needed to do so. By calling the function repeatedly given a stream of bytes, the caller can build up the original values. Returns a tuple with the following elements: * Bool indicating whether a complete value was decoded. * A decoded value if first value is True otherwise None * Integer number of bytes. If positive, the number of bytes read. If negative, the number of bytes we need to read to decode this value or the next chunk in this value. * One of the ``SPECIAL_*`` constants indicating special treatment for this value. ``SPECIAL_NONE`` means this is a fully decoded simple value (such as an integer or bool). rr TFN)allowindefinitezstring major type not supportedz,expected array after finite set semantic tagzsemantic tag %d not allowedzspecial type %d not allowed)rx SUBTYPE_MASKr: decodeuint SPECIAL_NONEr;r'r(#SPECIAL_START_INDEFINITE_BYTESTRINGMAJOR_TYPE_STRINGrpr?SPECIAL_START_ARRAYrWSPECIAL_START_MAPrLrM decodeitemSPECIAL_START_SETMAJOR_TYPE_SPECIAL SUBTYPE_FALSE SUBTYPE_TRUE SUBTYPE_NULLSUBTYPE_INDEFINITESPECIAL_INDEFINITE_BREAK) rcoffsetinitialr subtypecompleterZ readcountsizewantedtagvalue readcount2specials r"rr sI6 *G aKF1 I $GO#%/F%C" A |; ;$ <7 7 ' '%/F%C" $ $$%!Y]L@ @$ <7 7 + +%/ % ! $ <7 7  !D(CF29,v/AD/HIU$4q$8,FFQ&94t;dFL88q"EE E ' '?@@ & &%/w6$B! 1}.AA A$ <7 7 n $%/w6$B! 1}.?? ?$ <7 7 ) )(27v(F%I$ <7 7 . .!SV+dB 442<I%3 /HJdJ <<--%B:59;LL L""?("JK K ( ( m #</ /  $q,. .  $q,. . * *q":: :""?'"IJ Jur$cUS:aSUS4$US:XaU(ag[S5eUS:a[SU-5eUS:Xa[nO2US :Xa[nO%US :Xa[nOUS :Xa[nO [S 5e[ U5U- UR :a!SURX5SUR 4$S S[ U5U- UR - 4$)aDecode an unsigned integer. ``subtype`` is the lower 5 bits from the initial byte CBOR item "header." ``b`` is a buffer containing bytes. ``offset`` points to the index of the first byte after the byte that ``subtype`` was derived from. ``allowindefinite`` allows the special indefinite length value indicator. Returns a 3-tuple of (successful, value, count). The first element is a bool indicating if decoding completed. The 2nd is the decoded integer value or None if not fully decoded or the subtype is 31 and ``allowindefinite`` is True. The 3rd value is the count of bytes. If positive, it is the number of additional bytes decoded. If negative, it is the number of additional bytes needed to decode this value. rTrr )TNrz'indefinite length uint not allowed herez'unsupported subtype on integer type: %drrrz#bounds condition checking violationFN)rpSTRUCT_BIG_UBYTESTRUCT_BIG_USHORTSTRUCT_BIG_ULONGSTRUCT_BIG_ULONGLONGr(r unpack_from)rrcrrzrOs r"r}r}s.|Wa B  !"KL L B 5 ?  "}  B  B  B CDD 1v!&& Q]]1-a0!&&88dCFVOaff444r$c<\rSrSr%SrS\S'S\S'S S SjjrSrg) bytestringchunkizRepresents a chunk/segment in an indefinite length bytestring. This behaves like a ``bytes`` but in addition has the ``isfirst`` and ``islast`` attributes indicating whether this chunk is the first or last in an indefinite length bytestring. boolisfirstislastcH[RX5nX$lX4lU$r&)bytes__new__rr)clsr*firstlastselfs r"rbytestringchunk.__new__s}}S$   r$)rrN)FF)rrrr)rGrrrsrtru__annotations__rrvrbr$r"rrsM Lr$rcf\rSrSrSrSrSrSrSrSr Sr S r SS jr \ SS j5rSSS jjrS rSrg) sansiodecoderiaA CBOR decoder that doesn't perform its own I/O. To use, construct an instance and feed it segments containing CBOR-encoded bytes via ``decode()``. The return value from ``decode()`` indicates whether a fully-decoded value is available, how many bytes were consumed, and offers a hint as to how many bytes should be fed in next time to decode the next value. The decoder assumes it will decode N discrete CBOR values, not just a single value. i.e. if the bytestream contains uints packed one after the other, the decoder will decode them all, rather than just the initial one. When ``decode()`` indicates a value is available, call ``getavailable()`` to return all fully decoded values. ``decode()`` can partially decode input. It is up to the caller to keep track of what data was consumed and to pass unconsumed data in on the next invocation. The decoder decodes atomically at the *item* level. See ``decodeitem()``. If an *item* cannot be fully decoded, the decoder won't record it as partially consumed. Instead, the caller will be instructed to pass in the initial bytes of this item on the next invocation. This does result in some redundant parsing. But the overhead should be minimal. This decoder only supports a subset of CBOR as required by Mercurial. It lacks support for: * Indefinite length arrays * Indefinite length maps * Use of indefinite length bytestrings as keys or values within arrays, maps, or sets. * Nested arrays, maps, or sets within sets * Any semantic tag that isn't a mathematical finite set * Floating point numbers * Undefined special value CBOR types are decoded to Python types as follows: uint -> int negint -> int bytestring -> bytes map -> dict array -> list True -> bool False -> bool null -> None indefinite length bytestring chunk -> [bytestringchunk] The only non-obvious mapping here is an indefinite length bytestring to the ``bytestringchunk`` type. This is to facilitate streaming indefinite length bytestrings out of the decoder and to differentiate a regular bytestring from an indefinite length bytestring. rrrrr r r c^SUlURUl/UlSUl/UlgrS)decodedbytecount _STATE_NONE_state_collectionstack_currentmapkey_decodedvaluesrs r"__init__sansiodecoder.__init__.s7 !"&& !##!r$c4URUR:g$)z2Whether the decoder has partially decoded a value.)rrrs r" inprogresssansiodecoder.inprogressAs{{d....r$cU(d[UR5SS4$UnU[U5:Ga[X5upEpgUS:aU=RU- slU(d#US:de[UR5X#- U*4$X&- nUR UR :XGa U[:XaURRU5 GOU[:Xa1URRU/S.5 URUlGOU[:Xa1URRU0S.5 URUlGOU[:Xa9URRU[5S.5 UR UlGOKU[":XaUR$UlGO.['SU-5eUR UR:XGaU[:Xa2URSnUSRU5 US==S-ss'GOU[:XaRURSn /n U SRU 5 U S==S-ss'URRUU S.5 GOmU[:XabURSn 0n U SRU 5 U S==S-ss'URRXZS.5 URUlGOU[:XakURSn [5n U SRU 5 U S==S-ss'URRUU S.5 UR UlGOU[":Xa ['S5e['S U-5eUR UR:XafU[:XaXPlUR*UlGO,U[":Xa ['S 5eU[[[4;a ['S 5e['S U-5eUR UR*:XGaU[:Xa@URSn XYSUR('U S==S-ss'URUlGOfU[:Xa_URSn /n XSUR('U S==S-ss'URRUU S.5 URUlOU[:Xa_URSn 0n XSUR('U S==S-ss'URRUU S.5 URUlOU[:XagURSn [5n XSUR('U S==S-ss'URRUU S.5 UR UlO#U[":Xa ['S 5e['SU-5eSUlGOUR UR :XaU[:Xa2URSn U SR-U5 U S==S-ss'GOU[":Xa ['S5eU[[[4;a ['S5e['SU-5eUR UR$:XaU[:Xa6URR[/USS95 UR0UlGO"U[2:XaIURR[/SSSS95 UR(aeUR UlO['SU-5eUR UR0:XaU[:Xa%URR[/U55 OxU[2:XaHURR[/SSS95 UR(aeUR UlO&['SU-5e['SUR -5eUR URURUR 4;aOURSn U S(aOURR55 UR(aT[6UR[8UR[UR 0[;URSS5UlO/URRU S5 UR UlMU[U5:aGM[UR5X#- S4$)aMAttempt to decode bytes from an input buffer. ``b`` is a collection of bytes and ``offset`` is the byte offset within that buffer from which to begin reading data. ``b`` must support ``len()`` and accessing bytes slices via ``__slice__``. Typically ``bytes`` instances are used. Returns a tuple with the following fields: * Bool indicating whether values are available for retrieval. * Integer indicating the number of bytes that were fully consumed, starting from ``offset``. * Integer indicating the number of bytes that are desired for the next call in order to decode an item. r) remainingvzunhandled special state: %dr{rrrz9indefinite length bytestrings not allowed as array valuesz5unhandled special item when expecting array value: %dz5indefinite length bytestrings not allowed as map keysz%collections not supported as map keysz1unhandled special item when expecting map key: %dz7indefinite length bytestrings not allowed as map valuesz3unhandled special item when expecting map value: %dNz7indefinite length bytestrings not allowed as set valuesz%collections not allowed as set valuesz3unhandled special item when expecting set value: %dT)rr$)rrz">DK 11))00*/"$ #'":":DK 11))00*/"%% #'"<"  8 88l**/'"&"<"">DK 11 11"5E!H7?$K 3 34,'1,'))00*/"*#'":":DK 11 11"5E"uH7?$K 3 34,'1,'))00*/"*#'"<"[UR5n/UlU$)zuReturns an iterator over fully decoded values. Once values are retrieved, they won't be available on the next call. )rr)rr6s r" getavailablesansiodecoder.getavailables! $$ % r$)rrrrrNreturnNone)rrr)rintrtuple[bool, int, int])rGrrrsrtrurrrrrrrrpropertyrrrrvrbr$r"rrsX6pK)*&./+!&//G R r$rcR\rSrSr%SrS\S'S\S'S\S'SS jrSS jrS rS r g )bufferingdecoderiaPA CBOR decoder that buffers undecoded input. This is a glorified wrapper around ``sansiodecoder`` that adds a buffering layer. All input that isn't consumed by ``sansiodecoder`` will be buffered and concatenated with any new input that arrives later. TODO consider adding limits as to the maximum amount of data that can be buffered. r_decoderr_chunksr_wantedc>[5Ul/UlSUlgrS)rrrrrs r"rbufferingdecoder.__init__s%   r$c[U[5(a [U5nUR(a[ U5UR :aHURR U5 U=R [ U5-slSSUR 4$[ U5nURR U5 SRUR5n/Ul[ U5U- nOSnURRU5upEnX`lU[ U5:aURR XS5 XEU- U4$)aAttempt to decode bytes to CBOR values. Returns a tuple with the following fields: * Bool indicating whether new values are available for retrieval. * Integer number of bytes decoded from the new input. * Integer number of bytes wanted to decode the next value. Frr$N) rl bytearrayrrr(rrjoinrr)rrcnewlenoldlen availablerrs r"rbufferingdecoder.decodes a # #aA <<1v $ ##A& A& a--VF LL   "&ADLVf_FF'+}}';';A'>$ f s1v  LL  * .f,f44r$c6URR5$r&)rrrs r"rbufferingdecoder.getavailable!s}}))++r$)rrrNr)rr) rGrrrsrtrurrrrrvrbr$r"rrs) M L 15f,r$rcU(d/$[5nURU5up#nU[U5:wa [S5eUR(a [S5eUR 5$)a^Decode all CBOR items present in an iterable of bytes. In addition to regular decode errors, raises CBORDecodeError if the entirety of the passed buffer does not fully decode to complete CBOR values. This includes failure to decode any value, incomplete collection types, incomplete indefinite length items, and extra data at the end of the buffer. zinput data not fully consumedzinput data not complete)rrr(rprr)rcdecoder havevaluesr wantbytess r" decodeallr%sb  oG'.~~a'8$J9CF=>>788    !!r$)r rr!rrr)r*rrIterator[bytes])r/zIterable[bytes]rr)r)r4rrr)r*rrr)rr)rYrrr)r/rrr)rcrrr)r*rrr)r5rrrr)rr)rF)rrrcrrrrzr)N __future__rstructtyping TYPE_CHECKINGrrr:r;r'rr?rWrLrr|rrrSUBTYPE_HALF_FLOATSUBTYPE_SINGLE_FLOATSUBTYPE_DOUBLE_FLOATrrMrr-rCr]Structrrrrrr. BREAK_INTr#r+r1r7r=rArDrHrPr[r^rdrgrrrtuplerrrrFrir@ Exceptionrprxrrrrr~rrrrrrr}rrrrrbr$r"rs#       %kk 1 $'9 9  a "4 4{{.A  2 2==&=='=='=='=='    B  #2:#C '$   !  / J  4-i-==&MM%(=='}}U+ &'#XxFK25 2525$'25>B25je&jjZH,H,V"r$