6hdcSSKJr SSKrSSKrSSKrSSKJrJrJr SSKJ r \Rr Sr Sr \R"S S 5r"S S 5r"S S5r\"5r"SS5r"SS5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r\R3\"55 "SS\5r\R3\"55 "SS \5r\R3\"55 "S!S"\5r\R3\"55 "S#S$\5r\R3\"55 S%r\"5R?5r g)&) annotationsN)errori18npycompat) stringutilsserversclientcompenginewireprotosupport)nameserverpriorityclientpriorityc*\rSrSrSrSSjrSrSrg) propertycache!c2XlURUlgN)func__name__r )selfrs =/usr/lib/python3/dist-packages/mercurial/utils/compression.py__init__propertycache.__init__"s MM NcJURU5nURX5 U$r)r cachevalue)robjtyperesults r__get__propertycache.__get__&s 3 $ rc4X!RUR'gr)__dict__r )rrvalues rrpropertycache.cachevalue+s"' TYYr)rr r)r __module__ __qualname____firstlineno__rrr__static_attributes__rrrr!s" (rrcx\rSrSrSrSrSrSrSrSr \ S5r \ S 5r S r S rSS jrS rSrSrg)compressormanager0a/Holds registrations of various compression engines. This class essentially abstracts the differences between compression engines to allow new compression formats to be added easily, possibly from extensions. Compressors are registered against the global instance by calling its ``register()`` method. cJ0Ul0Ul0Ul0Ul0Ulgr)_engines _bundlenames _bundletypes_revlogheaders _wiretypesrs rrcompressormanager.__init__;s(  rc URU$rr.rkeys r __getitem__compressormanager.__getitem__Fs}}S!!rcXR;$rr6r7s r __contains__compressormanager.__contains__Ismm##rcH[URR55$r)iterr.keysr3s r__iter__compressormanager.__iter__LsDMM&&())rc[U[5(d[[S55eUR 5nX R ;a"[ R"[S5U-5eUR5nU(aUupEX@R;a"[ R"[S5U-5eXPR;a0[ R"[S5XPRU4-5eU(aX RU'X RU'UR5nU(aYURnXpR;a0[ R"[S5XpRU4-5eX RU'UR5nU(a?XR;a0[ R"[S5XRU4-5eU(aX RU'XR U'g)zhRegister a compression engine with the manager. The argument must be a ``compressionengine`` instance. s$argument must be a compressionengines(compression engine %s already registereds!bundle name %s already registereds'bundle type %s already registered by %ss5wire protocol compression %s already registered by %ss)revlog header %s already registered by %sN) isinstancecompressionengine ValueError_r r.rAbort bundletyper/r0wireprotosupportr2 revlogheaderr1) renginer bundleinfo bundlenamerI wiresupportwiretyperKs rregistercompressormanager.registerOs &"344QFGH H{{} == ++=>E &&( %/ "J...kk:;jH...kk@A!#4#4Z#@AB 04!!*-,0  j )--/ "''H??*kk, !:; <)-OOH %**, L,?,??++>?!4!4\!BCD  04   -$ drcH[URR55$r)setr/r@r3s rsupportedbundlenames&compressormanager.supportedbundlenames4$$))+,,rcH[URR55$r)rTr0r@r3s rsupportedbundletypes&compressormanager.supportedbundletypesrWrcURURUnUR5(d0[R"[ S5UR 5-5eU$)zObtain a compression engine registered to a bundle name. Will raise KeyError if the bundle type isn't registered. Will abort if the engine is known but not available. )compression engine %s could not be loaded)r.r/ availablerrHrGr )rrNrLs r forbundlenamecompressormanager.forbundlenameXt00<=!!++>?&++-O  rcURURUnUR5(d0[R"[ S5UR 5-5eU$)zObtain a compression engine registered to a bundle type. Will raise KeyError if the bundle type isn't registered. Will abort if the engine is known but not available. r\)r.r0r]rrHrGr )rrIrLs r forbundletypecompressormanager.forbundletyper`rcR^U[[4;deU[:XaSOSmURR5Vs/sHo0RUPM nnU(a(UVs/sHo3R 5(dMUPM nnU4Sjn[ [XES95$s snfs snf)zObtain compression engines that support the wire protocol. Returns a list of engines in prioritized order, most desired first. If ``onlyavailable`` is set, filter out engines that can't be loaded. r r cZ>UR5nS[UT5-UR4$)N)rJgetattrr )ewattrs rgetkey6compressormanager.supportedwireengines..getkeys.""$A4((!&&0 0r)r8) SERVERROLE CLIENTROLEr2valuesr.r]listsorted)rrole onlyavailablerhenginesrkrjs @rsupportedwireengines&compressormanager.supportedwireenginess J////#':#5;K-1__-C-C-EF-E==#-EF ");'Q[[]q'G; 1F7/00G;sB#B$?B$cURURUnUR5(d0[R"[ S5UR 5-5eU$)Nr\)r.r2r]rrHrGr )rrPrLs r forwiretypecompressormanager.forwiretypesTtx89!!++>?&++-O  rc:URURU$)z}Obtain a compression engine registered to a revlog header. Will raise KeyError if the revlog header value isn't registered. )r.r1)rheaders rforrevlogheader!compressormanager.forrevlogheaders }}T00899r)r/r0r.r1r2N)T)rr%r&r'__doc__rr9r<rArQpropertyrUrYr^rbrurxr|r(r)rrr+r+0sb "$*;%z----  12:rr+cP\rSrSrSrSrSrSrSrSr S S jr S r S S jr S r g)rEzmBase class for compression engines. Compression engines must implement the interface defined by this class. c[5e)zReturns the name of the compression engine. This is the key the engine is registered under. This method must be implemented. NotImplementedErrorr3s rr compressionengine.name "##rcg)zWhether the compression engine is available. The intent of this method is to allow optional compression engines that may not be available in all installations (such as engines relying on C extensions that may not be present). Tr)r3s rr]compressionengine.availablesrcg)aUDescribes bundle identifiers for this engine. If this compression engine isn't supported for bundles, returns None. If this engine can be used for bundles, returns a 2-tuple of strings of the user-facing "bundle spec" compression name and an internal identifier used to denote the compression format within bundles. To exclude the name from external usage, set the first element to ``None``. If bundle compression is supported, the class must also implement ``compressstream`` and `decompressorreader``. The docstring of this method is used in the help system to tell users about this engine. Nr)r3s rrIcompressionengine.bundletypes rcg)aDeclare support for this compression format on the wire protocol. If this compression engine isn't supported for compressing wire protocol payloads, returns None. Otherwise, returns ``compenginewireprotosupport`` with the following fields: * String format identifier * Integer priority for the server * Integer priority for the client The integer priorities are used to order the advertisement of format support by server and client. The highest integer is advertised first. Integers with non-positive values aren't advertised. The priority values are somewhat arbitrary and only used for default ordering. The relative order can be changed via config options. If wire protocol compression is supported, the class must also implement ``compressstream`` and ``decompressorreader``. Nr)r3s rrJ"compressionengine.wireprotosupports.rcg)a(Header added to revlog chunks that identifies this engine. If this engine can be used to compress revlogs, this method should return the bytes used to identify chunks compressed with this engine. Else, the method should return ``None`` to indicate it does not participate in revlog compression. Nr)r3s rrKcompressionengine.revlogheadersrNc[5e)aSCompress an iterator of chunks. The method receives an iterator (ideally a generator) of chunks of bytes to be compressed. It returns an iterator (ideally a generator) of bytes of chunks representing the compressed output. Optionally accepts an argument defining how to perform compression. Each engine treats this argument differently. rritoptss rcompressstream compressionengine.compressstream)s "##rc[5e)zPerform decompression on a file object. Argument is an object with a ``read(size)`` method that returns compressed data. Return value is an object with a ``read(size)`` that returns uncompressed data. rrfhs rdecompressorreader$compressionengine.decompressorreader5rrc[5e)aObtain an object that can be used to compress revlog entries. The object has a ``compress(data)`` method that compresses binary data. This method returns compressed binary data or ``None`` if the data could not be compressed (too small, not compressible, etc). The returned data should have a header uniquely identifying this compression format so decompression can be routed to this engine. This header should be identified by the ``revlogheader()`` return value. The object has a ``decompress(data)`` method that decompresses data. The method will only be called if ``data`` begins with ``revlogheader()``. The method should return the raw, uncompressed data or raise a ``StorageError``. The object is reusable but is not thread safe. rrrs rrevlogcompressor"compressionengine.revlogcompressor>s $"##rr)r)rr%r&r'r~r r]rIrJrKrrrr(r)rrrErEs/ $$2 $$$rrEc&\rSrSrSrSrSrSrg)_CompressedStreamReaderiSc[US5(aURUlOURUl/UlSUlSUlg)NunbufferedreadrF)hasattrr_readerread_pending_pos_eofrs rr _CompressedStreamReader.__init__Ts= 2' ( (,,DL77DL   rc[5err)rchunks r _decompress#_CompressedStreamReader._decompress]s !##rcz/nUR(Ga&[URS5XR-:a_URSnURX0RURU-5 U=RU- slSR U5$URR S5nUR(a9URX0RS5 U[U5UR- -nOURU5 U[U5-nSUlUR(aGM&UR (aSR U5$URS5nURU5 U(d3UR(d"UR (dSR U5$GM)Nrri) rlenrappendjoinpoprrr)rlbufnewbufrs rr_CompressedStreamReader.read`s=---t}}Q'(1yy=8!]]1-FJJvii$))a-@AIINI88C=(**1-99JJviik23Vtyy00AJJv&V$A --- yyxx}$LL'E   U #tyyxx}$/r)rrrrN)rr%r&r'rrrr(r)rrrrSs$%rrc.^\rSrSrU4SjrSrSrU=r$)_GzipCompressedStreamReaderi|cX>[TU]U5 [R"5Ulgr)superrzlib decompressobj _decompobjrr __class__s rr$_GzipCompressedStreamReader.__init__}s  ,,.rcZURRU5nU(aURRU5 URR 5nURS5 UR 5 UR S:XaSUlgg![Ra gf=f)NxT) r decompressrrcopyflush unused_datarrr)rrrds rr'_GzipCompressedStreamReader._decompresss++E2  MM  ( OO "  LL  GGI}}$  %zz   s8BB*)B*rrrr%r&r'rrr( __classcell__rs@rrr|s/  rrc.^\rSrSrU4SjrSrSrU=r$)_BZ2CompressedStreamReadericX>[TU]U5 [R"5Ulgr)rrbz2BZ2Decompressorrrs rr#_BZ2CompressedStreamReader.__init__s  --/rc0URRU5nU(aURRU5 URRS5nU(aURRU5 OgMA![a SUlgf=fNTr)rrrrEOFErrorrrrrs rr&_BZ2CompressedStreamReader._decompresss|++E2  MM  ( 33C8MM((0   DI s?B?BBBrrrs@rrrs0  rrc(^\rSrSrU4SjrSrU=r$)#_TruncatedBZ2CompressedStreamReaderic>[TU]U5 URRS5nU(aURR U5 gg)NBZ)rrrrrr)rrrrs rr,_TruncatedBZ2CompressedStreamReader.__init__s> ++E2  MM  ( rr))rr%r&r'rr(rrs@rrrs ))rrc.^\rSrSrU4SjrSrSrU=r$)_ZstdCompressedStreamReadericv>[TU]U5 X lUR5R 5Ulgr)rr_zstdZstdDecompressorrr)rrzstdrs rr$_ZstdCompressedStreamReader.__init__s.  //1??ArcPURRU5nU(aURRU5 URRS5nU(aURRU5 OgMA!URR a SUlgf=fr)rrrrr ZstdErrorrrs rr'_ZstdCompressedStreamReader._decompresss++E2  MM  ( 33C8MM((0  zz## DI s?B?B!B%$B%)rrrrrs@rrrsB  rrcZ\rSrSrSrSrSrSrS SjrSr "S S 5r S S jr S r g) _zlibengineicg)Nzlibr)r3s rr _zlibengine.namercg)zzlib compression using the DEFLATE algorithm. All Mercurial clients should support this format. The compression algorithm strikes a reasonable balance between compression ratio and size. )sgzipsGZr)r3s rrI_zlibengine.bundletypesrc[SSS5$)Nrcompewireprotosupportr3s rrJ_zlibengine.wireprotosupport$Wb"55rcg)Nrr)r3s rrK_zlibengine.revlogheadersrNc## U=(d 0n[R"URSS55nUH!nURU5nU(dMUv M# UR 5v g7f)Nlevelrf)r compressobjgetcompressrrrrzrdatas rr_zlibengine.compressstreamsZzr   TXXh3 4E::e$Dt ggi A A.A.c[U5$r)rrs rr_zlibengine.decompressorreaders *2..rc*\rSrSrSSjrSrSrSrg) _zlibengine.zlibrevlogcompressoriNcXlgr_level)rlevels rr)_zlibengine.zlibrevlogcompressor.__init__sKrc~[U5nUS:deUS:agUS::aVURc[R"U5nO [R"XR5n[U5U:aU$gURc[R"5nO[R"URS9n/nSnXb:a0US-nUR URXU55 UnXb:aM0UR UR 55 [[[U55U:aSRU5$g)Nr,@Brir) rrrrrrrsummapr)rrinsize compressedrpartspospos2s rr)_zlibengine.zlibrevlogcompressor.compresss YFA: :{7";;&!%t!4J!%t[[!AJz?V+%% ;;&((*A((t{{;Al;DLLDTN!;<Cl QWWY's3'&088E?*rc[R"U5$![Ra;n[R"[ S5[ R "U5-5eSnAff=f)Nrevlog decompress error: %s)rrr StorageErrorrGr forcebytestr)rrrhs rr+_zlibengine.zlibrevlogcompressor.decompress sY t,,:: ((45 --a01 sA'6A""A'rrrr%r&r'rrrr(r)rrzlibrevlogcompressorrs # J rrcPSnUbURS5nURU5$)Ns zlib.level)rrrrrs rr_zlibengine.revlogcompressors,  HH]+E((//rr)r) rr%r&r'r rIrJrKrrrrr(r)rrrrs06 /00d0rrc6\rSrSrSrSrSrS SjrSrSr g) _bz2engineicg)Nsbz2r)r3s rr _bz2engine.name srcg)a[An algorithm that produces smaller bundles than ``gzip``. All Mercurial clients should support this format. This engine will likely produce smaller bundles than ``gzip`` but will be significantly slower, both during compression and decompression. If available, the ``zstd`` engine can yield similar or better compression at much higher speeds. )bzip2rr)r3s rrI_bz2engine.bundletype#src[SSS5$)Nr$rrr3s rrJ_bz2engine.wireprotosupport3s$Xq!44rNc## U=(d 0n[R"URSS55nUH!nURU5nU(dMUv M# UR 5v g7f)Nr )r BZ2Compressorrrrrs rr_bz2engine.compressstream6sXzr   dhhx3 4E::e$Dt  ggirc[U5$r)rrs rr_bz2engine.decompressorreader@s )"--rr)r) rr%r&r'r rIrJrrr(r)rrr r s  5.rr c&\rSrSrSrSrSrSrg)_truncatedbz2engineiGcg)Ns bz2truncatedr)r3s rr _truncatedbz2engine.nameHsrcg)N)Ns _truncatedBZr)r3s rrI_truncatedbz2engine.bundletypeKs$rc[U5$r)rrs rr&_truncatedbz2engine.decompressorreaderPs 2266rr)N)rr%r&r'r rIrr(r)rrr/r/Gs% 7rr/cZ\rSrSrSrSrSrSrS SjrSr "S S 5r S S jr S r g) _noopengineiWcg)Nnoner)r3s rr _noopengine.nameXrrcg)z]No compression is performed. Use this compression engine to explicitly disable compression. )r9sUNr)r3s rrI_noopengine.bundletype[s rc[SSS5$)Nr9r rr3s rrJ_noopengine.wireprotosupportes$Wa44rcg)Nr)r3s rrK_noopengine.revlogheaderjsrNcU$rr)rs rr_noopengine.compressstreamm rcU$rr)rs rr_noopengine.decompressorreaderprErc\rSrSrSrSrg) _noopengine.nooprevlogcompressoriscgrr))rrs rr)_noopengine.nooprevlogcompressor.compresstsrr)N)rr%r&r'rr(r)rrnooprevlogcompressorrIss rrLc"UR5$r)rLrs rr_noopengine.revlogcompressorws((**rr)r) rr%r&r'r rIrJrKrrrLrr(r)rrr7r7Ws/5 +rr7cp\rSrSrSr\S5rSrSrSr Sr SS jr S r "S S 5r SS jrSrg) _zstdenginei~cg)Nzstdr)r3s rr _zstdengine.namerrcLSSKJn UR U$![a gf=f)Nr)r)r __version__ ImportError)rrs r_module_zstdengine._modules,     K  s  ##c,[UR5$r)boolrXr3s rr]_zstdengine.availablesDLL!!rcg)aA modern compression algorithm that is fast and highly flexible. Only supported by Mercurial 4.1 and newer clients. With the default settings, zstd compression is both faster and yields better compression than ``gzip``. It also frequently yields better compression than ``bzip2`` while operating at much higher speeds. If this engine is available and backwards compatibility is not a concern, it is likely the best available engine. )rRsZSr)r3s rrI_zstdengine.bundletypesrc[SSS5$)NrR2rr3s rrJ_zstdengine.wireprotosupportrrcg)N(r)r3s rrK_zstdengine.revlogheaderrrNc#.# U=(d 0nURSS5nURSS5nURnURX4S9R5nUH!nUR U5nU(dMUv M# UR 5v g7f)Nrsthreadsr)rthreads)rrXZstdCompressorrrr) rrrrrgrrrrs rr_zstdengine.compressstreamszr1%((:q)||   e  = I I KE::e$Dt  ggis A4B:Bc,[XR5$r)rrXrs rr_zstdengine.decompressorreaders*2||<>@DrrPc0n"SS5n[Hn[UnUR5(dM#UR5nU(a US(dMFSUS[R"UR54-nU"5n[R "U5UlURR UlURUlX`US'M U$)z@Obtains a list of available bundle compressions for use in help.c\rSrSrSrg)*bundlecompressiontopics..docobjectir)N)rr%r&r'r(r)rr docobjectrs rrrs ``%s`` %s) compenginesr]rIrgetdocsysstrr~_origdoc _origfunc)itemsrr rLbtdocr#s rbundlecompressiontopicsrs E  T"!!     A 2a5(//&:K:K*L"MM  , **22 ++be #& Lr)! __future__rr collectionsrrUrrrr rGrmrn namedtuplerrr+rrErrrrrrrQr r/r7rPrro i18nfunctionsr)rrrs} #    FF  #.. 0 ( (f:f:R ! t$t$n&%&%R"9&!8()*D)"9*Y0#Y0x []#"."".J Z\" 7+ 7 (*+!+#!+H []#DD#DDN []#@()002 r