chk`SSKJr SSKrSSKrSSKrSSKrSSKJrJrJ r J r J r SSK J r JrJrJrJr SSKJrJr SSKJr SrSSKJr S rS r"S S \5r"S S\5r"SS5r"SS\5r "SS\5r!"SS\5r""SS5r#"SS5r$g!\a N`f=f))BytesION)msb_size stream_copyapply_delta_dataconnect_deltas delta_types)allocate_memory LazyMixinmake_shawriteclose) NULL_BYTE BYTE_SPACE) force_bytesF) apply_deltaT) DecompressMemMapReaderFDCompressedSha1WriterDeltaApplyReader Sha1WriterFlexibleSha1WriterZippedStoreShaWriterrFDStream NullStreamc\rSrSrSrSrSrSSjrSrSr S r \ SS j5r S r S rS r\"\SS54SjrSSjrSrg)r.asReads data in chunks from a memory map and decompresses it. The client sees only the uncompressed data, respective file-like read calls are handling on-demand buffered decompression accordingly A constraint on the total size of bytes is activated, simulating a logical file within a possibly larger physical memory area To read efficiently, you clearly don't want to read individual bytes, instead, read a few kilobytes at least. **Note:** The chunk-size should be carefully selected as it will involve quite a bit of string copying due to the way the zlib is implemented. Its very wasteful, hence we try to find a good tradeoff between allocation time and number of times we actually allocate. An own zlib implementation would be good here to better support streamed reading - it would only need to keep the mmap and decompress it into chunks, that's all ... ) _m_zip_buf_buflen_br_cws_cwe_s_close_cbr_phiiNcXl[R"5UlSUlSUlUbX0lSUlSUlSUl SUl SUl X l g)ztInitialize with mmap for stream reading :param m: must be content data - use new if you have object data and no sizeNrF) rzlib decompressobjrrrr#r r!r"r%r&r$)selfmclose_on_deletionsizes _C:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\gitdb/stream.py__init__DecompressMemMapReader.__init__EsZ&&(    G    ' c4US:XdeUR5 g)Nr#)_parse_header_infor*attrs r. _set_cache_"DecompressMemMapReader._set_cache_Ust|| !r1c$UR5 gN)r r*s r.__del__DecompressMemMapReader.__del__[s  r1c*SnXlURU5nUR[5nUSUR [ 5upE[ U5nXPlSUlUS- n[X#S5Ul [U5U- Ul SUl XE4$)zIf this stream contains object data, parse the header info and skip the stream to a point where each read will yield object content :return: parsed type_string, sizei NrT) r#readfindrsplitrintr rrlenrr&)r*maxbhdrhdrendtypr-s r.r3)DecompressMemMapReader._parse_header_info^siio)$L&&z2 4y! CL) 3x&(  yr1cF[XS5nUR5upEXEU4$)a~Create a new DecompressMemMapReader instance for acting as a read-only stream This method parses the object header from m and returns the parsed type and size, as well as the created stream instance. :param m: memory map on which to operate. It must be object data ( header + contents ) :param close_on_deletion: if True, the memory map will be closed once we are being deletedr)rr3)r*r+r,instrGr-s r.newDecompressMemMapReader.new{s*&aA>++- $r1cUR$)z8:return: random access compatible data we are working on)rr:s r.dataDecompressMemMapReader.datas wwr1cUR(a=[URS5(aURR5 SUlgg)zClose our underlying stream of compressed bytes if this was allowed during initialization :return: True if we closed the underlying stream :note: can be called safely r FN)r$hasattrrr r:s r.r DecompressMemMapReader.closes5 ;;tww(( DK r1c URUR:XGa^URR(GdBSUl[ URS5(arURR [ R:XaIUR[R5 URR [ R:XaMIOURR(dUR[UR5:wa_UR[R5 URR(d%UR[UR5:waM_URUlUR$)z| :return: number of compressed bytes read. This includes the bytes it took to decompress the header ( if there was one )rstatus)r r#r unused_datarQrTr(Z_OKr?mmapPAGESIZEr%rCrr:s r.compressed_bytes_read,DecompressMemMapReader.compressed_bytes_reads0 88tww tyy'<'<'<DHtyy(++ii&&$))3IIdmm,ii&&$))3 ))//DIITWW4MIIdmm,))//DIITWW4M wwDH yyr1SEEK_SETrcUS:wdU[[SS5:wa [S5e[R"5UlS=Ul=Ul=UlUl UR(a SUl U? gg)z_Allows to reset the stream to restart reading :raise ValueError: If offset and whence are not 0rr[Can only seek to position 0FN) getattros ValueErrorr(r)rr r!r"r%r&r#r*offsetwhences r.seekDecompressMemMapReader.seeksm Q;&GB A$>>:; ;&&( 7888498ty49 99DI r1cUS:aURUR- nO"[XRUR- 5nUS:XagSnUR(aURU:aGURR U5nU=RU-slU=RU- slU$URR 5nXR-nU=RUR- slSUlSUlUR RnU(a2UR[U5- Ul URU-UlO&URnURUl XA-UlURUR- S:aURS-UlURURURnUR[U5-UlUR RXQ5n[[S[R5S;a4[ R"S:Xd [UR R5nO?[UR R5[UR R$5-nU=R&[U5U- - slU=R[U5- slU(aX&-nU(aT[U5[U5- U:a9URUR:aX`R U[U5- 5- nU$)Nr>rr1ZLIB_RUNTIME_VERSION)z1.2.7z1.2.5darwin)r#r minrrr?runconsumed_tailr"rCr!r decompressr^r( ZLIB_VERSIONsysplatformrUr%)r*r-dattailcwsindatadcompdatunused_datalens r.r?DecompressMemMapReader.readsj !877TXX%DtWWtxx/0D 19  99||t#iinnT* $ D  iinn& $DLL(    yy((  CI-DI D(DI))C DI DI 99tyy 1 $ A DI499-IIF + 99''5 4/1B1B CGY Ybebnbnrzbz !:!:;N !:!:;c$))BWBW>XXN S[>11  CM! ~H XS1T9dhh>P  $X"67 7Hr1) r rrr%r$r"r!rr&r#rr9F))__name__ __module__ __qualname____firstlineno____doc__ __slots__ max_read_sizer/r6r;r3 classmethodrKrNr rYr^r_rdr?__static_attributes__r1r.rr.sf: !IM( " :   -b#*"j!"< ir1rc\rSrSrSrSrSrSrSrSr \ (d\ r O\r SS jr \ "\S S54S jr\S 5r\S 5r\S5r\S5rSrg)riBayA reader which dynamically applies pack deltas to a base object, keeping the memory demands to a minimum. The size of the final object is only obtainable once all deltas have been applied, unless it is retrieved from a pack index. The uncompressed Delta has the following layout (MSB being a most significant bit encoded dynamic size): * MSB Source Size - the size of the base against which the delta was created * MSB Target Size - the size of the resulting data after the delta was applied * A list of one byte commands (cmd) which are followed by a specific protocol: * cmd & 0x80 - copy delta_data[offset:offset+size] * Followed by an encoded offset into the delta data * Followed by an encoded size of the chunk to copy * cmd & 0x7f - insert * insert cmd bytes from the delta buffer into the output stream * cmd == 0 - invalid operation ( or error in delta stream ) )_bstream _dstreams _mm_target_sizer icx[U5S:dS5eUSUl[USS5UlSUlg)zInitialize this instance with a list of streams, the first stream being the delta to apply on top of all following deltas, the last stream being the base object onto which to apply the deltasr>z+Need at least one delta and one base streamrxNr)rCrtuplerr )r* stream_lists r.r/DeltaApplyReader.__init__hsB;!#R%RR##B {3B/0r1c[UR5S:XaURU5$[UR5nUR 5S:XaSUl[ S5UlgUR 5Ul[ UR 5Ul[ URR5n[URRURURRS[R-5 URRnURX45 URR!S5 g)Nr>r)rCr_set_cache_brute_rrboundrr rrr-rr?r rWrXapplyrd)r*r5dclbbufr s r._set_cache_too_slow_without_c.DeltaApplyReader._set_cache_too_slow_without_crs t~~ ! #))$/ / T^^, ::<1 DJ-a0DO ZZ\ )$**5t}}112DMM&& DMM4F4FdmmH[\%% $ Qr1c [5nSnURHOnURS5n[U5upg[XV5uphUR XVSXgU45 [ X85nMQ UR Rn Un[UR5S:a [ X5=p[U 5n [UR RU RU S[R-5 [U5n Sn [[U5[UR55Huuppxn[URU- 5nURU 5 [URURURS[R-5 S[!5;a [#XU 5 O![%XU[U5U R5 XpU R'S5 U R'S5 Un M XlXlg)z*If we are here, we apply the actual deltasriNr>r c_apply_delta)listrr?rappendmaxrr-rCr rr rWrXzipreversedglobalsrrrdrr)r*r5buffer_info_listmax_target_sizedstreambufrbsrc_size target_size base_sizertbuffinal_target_sizedbufddatas r.r"DeltaApplyReader._set_cache_brute_s  6~~G,,s#C'} F"*3"7 F  # #S\6[$Q R!/?O &MM&& %  t~~  "&))&E EI y)DMM&& IsT]]?RS {+ !>A(K[B\^fgkgugu^v>w : 1T87 $GLL6$9:E KK   ekk7<<t}}AT U')+d40 E DJJO $ IIaL IIaL + /?x:& r1rcURUR- nUS:dX:aUnURRU5nU=R[ U5- slU$)Nr>)rr rr?rC)r*countblrNs r.r?DeltaApplyReader.readsQ ZZ$(( " 19 E##E* CI r1r[cUS:wdU[[SS5:wa [S5eSUlURR S5 g)z`Allows to reset the stream to restart reading :raise ValueError: If offset and whence are not 0rr[r]N)r^r_r`r rrdras r.rdDeltaApplyReader.seeks@ Q;&GB A$>>:; ; Qr1c[U5S:a [S5eUSR[;a[SUSR-5eU"U5$)a Convert the given list of streams into a stream which resolves deltas when reading from it. :param stream_list: two or more stream objects, first stream is a Delta to the object that you want to resolve, followed by N additional delta streams. The list's last stream must be a non-delta stream. :return: Non-Delta OPackStream object whose stream can be used to obtain the decompressed resolved data :raise ValueError: if the stream list cannot be handledzNeed at least two streamsrxzNCannot resolve deltas if there is no base object stream, last one was type: %s)rCr`type_idrtype)clsrs r.rKDeltaApplyReader.newsb { a 89 9 r? " "k 1`cnoqcrcwcwwy y;r1c.URR$r9)rrr:s r.rDeltaApplyReader.types}}!!!r1c.URR$r9)rrr:s r.rDeltaApplyReader.type_ids}}$$$r1cUR$)z3:return: number of uncompressed bytes in the stream)rr:s r.r-DeltaApplyReader.sizeszzr1)r rrrrNr)ryrzr{r|r}r~k_max_memory_mover/rr has_perf_modr6r?r^r_rdrrKpropertyrrr-rrr1r.rrBs0I*  DH'V ' 3 #*"j!"<   4""%%r1rc2\rSrSrSrSrSrSrS SjrSr g) ri,zlSimple stream writer which produces a sha whenever you like as it degests everything it is supposed to writesha1c"[5Ulgr9)r rr:s r.r/Sha1Writer.__init__2s J r1cNURRU5 [U5$)zk:raise IOError: If not all bytes could be written :param data: byte object :return: length of incoming data)rupdaterCr*rNs r.r Sha1Writer.write7s 4yr1cxU(aURR5$URR5$)zU:return: sha so far :param as_hex: if True, sha will be hex-encoded, binary otherwise)r hexdigestdigest)r*as_hexs r.shaSha1Writer.shaDs- 99&&( (yy!!r1)rNrw) ryrzr{r|r}r~r/r rrrr1r.rr,s*I "r1rc(\rSrSrSrSrSrSrSrg)riNzVWriter producing a sha1 while passing on the written bytes to the given write functionwriterc:[RU5 Xlgr9)rr/r)r*rs r.r/FlexibleSha1Writer.__init__TsD! r1cP[RX5 URU5 gr9)rr rrs r.r FlexibleSha1Writer.writeXs$ Dr1)rN) ryrzr{r|r}r~r/r rrr1r.rrNsIr1rcV\rSrSrSrSrSrSrSrSr \ "\ SS 54S jr S r Srg ) ri]z=Remembers everything someone writes to it and generates a sha)rrc[RU5 [5Ul[R "[R 5Ulgr9)rr/rrr( compressobj Z_BEST_SPEEDrr:s r.r/ZippedStoreShaWriter.__init__bs1D!9##D$5$56r1c.[URU5$r9)r^rr4s r. __getattr__ ZippedStoreShaWriter.__getattr__gstxx&&r1c[RX5nURRURR U55 U$r9)rr rrcompress)r*rNalens r.r ZippedStoreShaWriter.writejs6+ txx((./ r1cjURRURR55 gr9)rr rflushr:s r.r ZippedStoreShaWriter.closeps txx~~'(r1r[rcUS:wdU[[SS5:wa [S5eURR S5 g)zXSeeking currently only supports to rewind written data Multiple writes are not supportedrr[r]N)r^r_r`rrdras r.rdZippedStoreShaWriter.seekss7 Q;&GB A$>>:; ;  ar1c6URR5$)zA:return: string value from the current stream position to the end)rgetvaluer:s r.rZippedStoreShaWriter.getvalue{sxx  ""r1N)ryrzr{r|r}r~r/rr r r^r_rdrrrr1r.rr]s6GI7 ' )#*"j!"<#r1rcL^\rSrSrSrSr\"S5rU4SjrSr Sr Sr U=r $) rizDigests data written to it, making the sha available, then compress the data and write it to the file descriptor **Note:** operates on raw file descriptors **Note:** for this to work, you have to use the close-method of this instance)fdrrz+Failed to write all bytes to filedescriptorc>[TU]5 Xl[R"[R 5Ulgr9)superr/rr(rrr)r*r __class__s r.r/FDCompressedSha1Writer.__init__s+ ##D$5$56r1cURRU5 URRU5n[ UR U5nU[ U5:wa URe[ U5$)zR:raise IOError: If not all bytes could be written :return: length of incoming data)rrrrr rrCexc)r*rNcdata bytes_writtens r.r FDCompressedSha1Writer.writesY !!$'dggu- CJ &((N4yr1cURR5n[URU5[ U5:wa UR e[ UR5$r9)rrr rrCrr )r* remainders r.r FDCompressedSha1Writer.closes@HHNN$ ) $I 6((NTWW~r1)rr) ryrzr{r|r}r~IOErrorrr/r r r __classcell__)rs@r.rrs1U &I ? @C7 r1rcD\rSrSrSrSrSrSrS SjrSr Sr S r Sr g ) rizA simple wrapper providing the most basic functions on a file descriptor with the fileobject interface. Cannot use os.fdopen as the resulting stream takes ownership_fd_poscXlSUlgNrr)r*rs r.r/FDStream.__init__s r1cU=R[U5- sl[R"URU5 gr9)rrCr_r rrs r.r FDStream.writes& SY  4 r1cUS:Xa)[RRUR5n[R"UR U5nU=R [U5- slU$r)r_pathgetsize _filepathr?rrrC)r*rbytess r.r? FDStream.readsL A:GGOODNN3E%( SZ  r1cUR$r9)rr:s r.filenoFDStream.filenos xxr1cUR$r9)rr:s r.tell FDStream.tells yyr1c.[UR5 gr9)r rr:s r.r FDStream.closes  dhhr1Nr) ryrzr{r|r}r~r/r r?rr r rrr1r.rrs, I!r1rc<\rSrSrSr\"5rSSjrSrSr Sr g) rizRA stream that does nothing but providing a stream interface. Use it like /dev/nullcg)Nr)r*r-s r.r?NullStream.readsr1cgr9rr:s r.r NullStream.closes r1c[U5$r9)rCrs r.r NullStream.writes 4yr1rNr) ryrzr{r|r}rr~r?r r rrr1r.rrsI r1r)%iorrWr_rnr( gitdb.funrrrrr gitdb.utilr r r r r gitdb.constrrgitdb.utils.encodingrrgitdb_speedups._perfrr ImportError__all__rrrrrrrrrr1r.rs  .,  AL %QYQh`y`T""D   #: #F#Z#PD  M  sB$$B-,B-