o V hft@sdZddlmZddlZddlZddlZddlmZddlmZddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZerddlm Z ddlm!Z!ddl"m#Z#ddlm$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*e+e,Z-Gddde.Z/Gddde/Z0Gdd d e/Z1Gd!d"d"e/Z2Gd#d$d$e/Z3d6d,d-Z4Gd.d/d/Z5Gd0d1d1ee6Z7Gd2d3d3e7Z8Gd4d5d5e8Z9dS)7zLazy ZIP over HTTP) annotationsN) bisect_left) bisect_right)contextmanager)NamedTemporaryFile)IO) TYPE_CHECKING)Any)ClassVar)urlparse) BadZipFile)ZipFile) parse_email)CONTENT_CHUNK_SIZE) HTTPError)Response)codes)Iterable)Iterator) TracebackType) RawMetadata)Session)Self) Authenticatorc@eZdZdZdS)LazyWheelUnsupportedErrorz(Raised when a lazy wheel is unsupported.N__name__ __module__ __qualname____doc__r!r!p/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/poetry/inspection/lazy_wheel.pyr+rc@r) HTTPRangeRequestUnsupportedErrorzDRaised when the remote server appears unable to support byte ranges.Nrr!r!r!r"r$/r#r$c@r)!HTTPRangeRequestNotRespectedErrorzrRaised when the remote server tells us that it supports byte ranges but does not respect a respective request.Nrr!r!r!r"r%3r#r%c@r)UnsupportedWheelErrorzUnsupported wheel.Nrr!r!r!r"r&8r#r&c@s$eZdZdZd ddZd d d Zd S)InvalidWheelErrorzInvalid (e.g. corrupt) wheel.locationstrnamereturnNonecCs||_||_dSN)r(r*)selfr(r*r!r!r"__init__?s zInvalidWheelError.__init__cCsd|jd|jdS)NzWheel z located at z is invalid.)r*r(r.r!r!r"__str__CszInvalidWheelError.__str__N)r(r)r*r)r+r,r+r))rrrr r/r1r!r!r!r"r'<s r'r*r)urlsessionSession | Authenticatorr+rc Csz#t|| }||}Wdn1swYt|\}}|WSttfy1t||ty[}zt|tr?|t dt |j |||td|d|d|d}~ww)aiFetch metadata from the given wheel URL. This uses HTTP range requests to only fetch the portion of the wheel containing metadata, just enough for the object to be constructed. :raises HTTPRangeRequestUnsupportedError: if range requests are unsupported for ``url``. :raises InvalidWheelError: if the zip file contents could not be parsed. NzYThere was an unexpected %s when handling lazy wheel metadata retrieval for %s from %s: %sz2Attempts to use lazy wheel metadata retrieval for z from z failed) LazyWheelOverHTTP read_metadatarr r&r' Exception isinstancerloggerdebugtyper)r*r3r4 lazy_filemetadata_bytesmetadata_er!r!r"metadata_from_wheel_urlGs2      rBc@s@eZdZdZddddd d Zdd d ZdddZdddZdS)MergeIntervalsz.Stateful bookkeeping to merge interval graphs.r!)leftrightrD Iterable[int]rEr+r,cCst||_t||_dSr-)list_left_right)r.rDrEr!r!r"r/ws zMergeIntervals.__init__r)cCs(t|jdt|jdt|jdS)Nz(left=z, right=))r<rtuplerHrIr0r!r!r"__repr__{s zMergeIntervals.__repr__startintendIterator[tuple[int, int]]c cs|j|||j||}}t|g|dd}}t|g|dd}t||D]\}} ||kr<||dfV| d}q-||krJ||fV|g|g|j||<|j||<dS)aReturn an iterator of intervals to be fetched. Args: start: Start of needed interval end: End of needed interval left: Index of first overlapping downloaded data right: Index after last overlapping downloaded data N)rHrIminmaxzip) r.rMrOrDrElslicersliceijkr!r!r"_merges   &zMergeIntervals._mergeccs4t|j|}t|j|}|||||EdHdS)a^Provide the intervals needed to cover from ``start <= x <= end``. This method mutates internal state so that later calls only return intervals not covered by prior calls. The first call to this method will always return exactly one interval, which was exactly the one requested. Later requests for intervals overlapping that first requested interval will yield only the ranges not previously covered (which may be empty, e.g. if the same interval is requested twice). This may be used e.g. to download substrings of remote files on demand. N)rrIrrHr[)r.rMrOrDrEr!r!r"minimal_intervals_coverings  z)MergeIntervals.minimal_intervals_coveringN)rDrFrErFr+r,r2) rMrNrOrNrDrNrErNr+rP)rMrNrOrNr+rP)rrrr r/rLr[r\r!r!r!r"rCts   rCc@s eZdZdZdNddZdOd d ZdPddZdQddZdRddZe dSddZ e dSddZ dTdd Z dUd!d"Z e dTd#d$ZdVd&d'ZdUd(d)ZdTd*d+ZdTd,d-ZdWdXd0d1ZdWdYd3d4ZdWdZd7d8Zd[d\dd?Zd]d^dBdCZdTdDdEZd_dHdIZd`dLdMZd@S)aReadOnlyIOWrapperzImplement read-side ``IO[bytes]`` methods wrapping an inner ``IO[bytes]``. This wrapper is useful because Python currently does not distinguish read-only streams at the type level. inner IO[bytes]r+r,cCs ||_dSr-)_file)r.r^r!r!r"r/ zReadOnlyIOWrapper.__init__rcCs|j|Sr-)r` __enter__r0r!r!r"rbs zReadOnlyIOWrapper.__enter__exc_typetype[BaseException] | None exc_valueBaseException | None tracebackTracebackType | NonecCs|j|||dSr-)r`__exit__r.rcrergr!r!r"riszReadOnlyIOWrapper.__exit__Iterator[bytes]cCtr-NotImplementedErrorr0r!r!r"__iter__zReadOnlyIOWrapper.__iter__bytescCrlr-rmr0r!r!r"__next__rpzReadOnlyIOWrapper.__next__r)cCdS)z!Opening mode, which is always rb.rbr!r0r!r!r"modeszReadOnlyIOWrapper.modecC|jjS)zPath to the underlying file.)r`r*r0r!r!r"r*zReadOnlyIOWrapper.nameboolcCrs)z9Return whether random access is supported, which is True.Tr!r0r!r!r"seekablezReadOnlyIOWrapper.seekablecCs|jdS)zClose the file.N)r`closer0r!r!r"r{szReadOnlyIOWrapper.closecCrv)zWhether the file is closed.)r`closedr0r!r!r"r|rwzReadOnlyIOWrapper.closedrNcC |jSr-)r`filenor0r!r!r"r~razReadOnlyIOWrapper.filenocCs|jdSr-)r`flushr0r!r!r"rszReadOnlyIOWrapper.flushcCrs)NFr!r0r!r!r"isattyrpzReadOnlyIOWrapper.isattycCrs)z3Return whether the file is readable, which is True.Tr!r0r!r!r"readablerzzReadOnlyIOWrapper.readablerRsizecC |j|S)zRead up to size bytes from the object and return them. As a convenience, if size is unspecified or -1, all bytes until EOF are returned. Fewer than size bytes may be returned if EOF is reached. )r`readr.rr!r!r"rs zReadOnlyIOWrapper.readlimitcCrlr-rm)r.rr!r!r"readlinerzzReadOnlyIOWrapper.readlinehint list[bytes]cCrlr-rm)r.rr!r!r" readlinesrpzReadOnlyIOWrapper.readlinesroffsetwhencecCs|j||S)a-Change stream position and return the new absolute position. Seek to offset relative position indicated by whence: * 0: Start of stream (the default). pos should be >= 0; * 1: Current position - pos may be negative; * 2: End of stream - pos usually negative. )r`seek)r.rrr!r!r"rszReadOnlyIOWrapper.seekcCr})zReturn the current position.)r`tellr0r!r!r"rs zReadOnlyIOWrapper.tellN int | NonecCr)zResize the stream to the given size in bytes. If size is unspecified resize to the current position. The current stream position isn't changed. Return the new file size. )r`truncaterr!r!r"rs zReadOnlyIOWrapper.truncatecCrs)z Return False.Fr!r0r!r!r"writablerzzReadOnlyIOWrapper.writablesr cCrlr-rm)r.rr!r!r"writerpzReadOnlyIOWrapper.writelines Iterable[Any]cCrlr-rm)r.rr!r!r" writelinesrpzReadOnlyIOWrapper.writelines)r^r_r+r,r+rrcrdrerfrgrhr+r,)r+rk)r+rqr2)r+rxr+r,r+rNrRrrNr+rq)rrNr+rq)rrNr+r)r)rrNrrNr+rNr-)rrr+rN)rr r+rN)rrr+r,)rrrr r/rbrirorrpropertyrur*ryr{r|r~rrrrrrrrrrrrr!r!r!r"r]s8                   r]cseZdZdZ d6d7fd d Zd8fdd Zd9fdd Zd:d;fdd Zedd%d&Z d>d'd(Z d?d,d-Zd@d/d0ZedAd2d3ZdBd4d5ZZS)CLazyFileOverHTTPaFile-like object representing a fixed-length file over HTTP. This uses HTTP range requests to lazily fetch the file's content into a temporary file. If such requests are not supported by the server, raises ``HTTPRangeRequestUnsupportedError`` in the ``__enter__`` method.Tr3r)r4r5delete_backing_filerxr+r,cs8t|d}t|d|_d|_d|_||_||_dS)N)deleter)rsuperr/_merge_intervals_length_request_count_session_url)r.r3r4rr^ __class__r!r"r/$s   zLazyFileOverHTTP.__init__rcst||Sr-)rrb_setup_contentr0rr!r"rb4s zLazyFileOverHTTP.__enter__rcrdrerfrgrhcs|t|||dSr-)_reset_contentrrirjrr!r"ri9szLazyFileOverHTTP.__exit__rRrrNrqcs|jdur td|}td|||j|dkr'||jks!J|j|}n|dkr-dS|}t|||j}|||t |S)a-Read up to size bytes from the object and return them. As a convenience, if size is unspecified or -1, all bytes until EOF are returned. Fewer than size bytes may be returned if EOF is reached. :raises ValueError: if ``__enter__`` was not called beforehand. Nz4.__enter__() must be called to set up content lengthz$read size %d at %d from lazy file %sr) r ValueErrorrr:r;r*rS_ensure_downloadedrr)r.rcur download_sizestoprr!r"rBs    zLazyFileOverHTTP.readdict[str, str]cCs dddS)aHTTP headers to bypass any HTTP caching. The requests we perform in this file are intentionally small, and any caching should be done at a higher level. Further, caching partial requests might cause issues: https://github.com/pypa/pip/pull/8716 identityzno-cache)zAccept-Encodingz Cache-Controlr!clsr!r!r"_uncached_headersZs z"LazyFileOverHTTP._uncached_headerscCs`|jdur t|_|jdur'td||_td|j||jdStd|jdS)a!Initialize the internal length field and other bookkeeping. Ensure ``self._merge_intervals`` is initialized. After parsing the remote file length with ``self._fetch_content_length()``, this method will truncate the underlying file from parent abstract class ``ReadOnlyIOWrapper`` to that size in order to support seek operations against ``io.SEEK_END`` in ``self.read()``. Called in ``__enter__``, and should make recursive invocations into a no-op. Subclasses may override this method.Nzbegin fetching content lengthz%done fetching content length (is: %d)z'content length already fetched (is: %d))rrCrr:r;_fetch_content_lengthrr0r!r!r"ris    zLazyFileOverHTTP._setup_contentcCsH|jdurtdt|jd|_|jdur"td|jd|_dSdS)zUnset the internal length field and merge intervals. Called in ``__exit__``, and should make recursive invocations into a no-op. Subclasses may override this method.Nz$unsetting merge intervals (were: %s)z"unsetting content length (was: %d))rr:r;reprrr0r!r!r"rs    zLazyFileOverHTTP._reset_contentcCsr|jd7_|jj|j|dd}||jtjksJ|j dd}|dkr2t d|dt |j d S) zPerforms a HEAD request to extract the Content-Length. :raises HTTPRangeRequestUnsupportedError: if the response fails to indicate support for "bytes" ranges.rQT)headersallow_redirects Accept-RangesNrqz1server does not support byte ranges: header was ''Content-Length) rrheadrrraise_for_status status_coderokrgetr$rN)r.raccepted_ranger!r!r"_content_length_from_heads  z*LazyFileOverHTTP._content_length_from_headcCs|S)zGet the remote file's length.)rr0r!r!r"rsz&LazyFileOverHTTP._fetch_content_lengthrMrOrcCs|}d|d||d<td|d|jd7_|jj|j|dd}z&|t|j d||dkrKt d ||dd |j dd |WSt yY| w) zDReturn streaming HTTP response to a range request from start to end.zbytes=-Rangezstreamed bytes request: %srQTrstreamrz5server did not respect byte range request: requested z bytes, got z bytes) rr:r;rrrrrrNrr% BaseExceptionr{)r.rMrOrresponser!r!r"_stream_responses(  z!LazyFileOverHTTP._stream_responserkccsD|||}|tEdHWddS1swYdS)a7Perform a series of HTTP range requests to cover the specified byte range. NB: For compatibility with HTTP range requests, the range provided to this method must *include* the byte indexed at argument ``end`` (so e.g. ``0-1`` is 2 bytes long, and the range can never be empty). N)r iter_contentr)r.rMrOrr!r!r"_fetch_content_ranges"z%LazyFileOverHTTP._fetch_content_rangeIterator[None]c cs.|}z dVW||dS||w)zyReturn a context manager keeping the position. At the end of the block, seek back to original position. N)rr)r.posr!r!r"_stays zLazyFileOverHTTP._staycCs|jdur td|d8}|)|j||D]\}}|||||D]}|j|q(qWddS1s=wYdS)zEnsures bytes start to end (inclusive) have been downloaded and written to the backing file. :raises ValueError: if ``__enter__`` was not called beforehand. Nz5.__enter__() must be called to set up merge intervalsrQ)rrrr\rrr`r)r.rMrO range_start range_endchunkr!r!r"rs    "z#LazyFileOverHTTP._ensure_downloaded)T)r3r)r4r5rrxr+r,rrrr)r+rrr)rMrNrOrNr+r)rMrNrOrNr+rk)r+r)rMrNrOrNr+r,)rrrr r/rbrir classmethodrrrrrrrrrr __classcell__r!r!rr"rs$           rc@sxeZdZUdZeZded<edZ dd d Z e dd d Z dddZ edddZd ddZd!ddZd"ddZdS)#r6zFile-like object mapped to a ZIP file over HTTP. This uses HTTP range requests to lazily fetch the file's content, which should be provided as the first argument to a ``ZipFile``. zClassVar[set[str]]_domains_without_negative_rangez^[^/]*\.dist-info/METADATA$r*r)r+rqcCs@t|}||}||WdS1swYdS)z:Download and read the METADATA file from the remote wheel.N)r _prefetch_metadatar)r.r*zffilenamer!r!r"r7s  $zLazyWheelOverHTTP.read_metadatarNcCrs)a<Return the size of the chunk (in bytes) to download from the end of the file. This method is called in ``self._fetch_content_length()``. As noted in that method's docstring, this should be set high enough to cover the central directory sizes of the *average* wheels you expect to see, in order to avoid further requests before being able to process the zip file's contents at all. If we choose a small number, we need one more range request for larger wheels. If we choose a big number, we download unnecessary data from smaller wheels. If the chunk size from this method is larger than the size of an entire wheel, that may raise an HTTP error, but this is gracefully handled in ``self._fetch_content_length()`` with a small performance penalty. i'r!rr!r!r"_initial_chunk_lengthsz'LazyWheelOverHTTP._initial_chunk_lengthc Cs2|}||\}}|||dur#td||}||||S|h|Mt|jd}|t||ks;J| | t j | t D]}|j|qH||}|d}|jdus`J||fft|j||kspJWdn1szwYWd|SWd|S1swY|S)aGet the total remote file length, but also download a chunk from the end. This method is called within ``__enter__``. In an attempt to reduce the total number of requests needed to populate this lazy file's contents, this method will also attempt to fetch a chunk of the file's actual content. This chunk will be ``self._initial_chunk_length()`` bytes in size, or just the remote file's length if that's smaller, and the chunk will come from the *end* of the file. This method will first attempt to download with a negative byte range request, i.e. a GET with the headers ``Range: bytes=-N`` for ``N`` equal to ``self._initial_chunk_length()``. If negative offsets are unsupported, it will instead fall back to making a HEAD request first to extract the length, followed by a GET request with the double-ended range header ``Range: bytes=X-Y`` to extract the final ``N`` bytes from the remote resource. NrrrQ)r_extract_content_lengthrrTrrrNrrSrioSEEK_ENDrrr`rrrKr\) r.initial_chunk_size ret_lengthtail initial_startresponse_lengthrinit_chunk_startinit_chunk_endr!r!r"r s6    ( z'LazyWheelOverHTTP._fetch_content_lengthargcCs2td|}|durtd|dt|dS)zParse the file's full underlying length from the Content-Range header. This supports both * and numeric ranges, from success or error responses: https://www.rfc-editor.org/rfc/rfc9110#field.content-range. zbytes [^/]+/([0-9]+)Nz could not parse Content-Range: 'rrQ)rematchr$rNgroup)rmr!r!r"%_parse_full_length_from_content_rangeHs  z7LazyWheelOverHTTP._parse_full_length_from_content_rangertuple[int, Response]cCs|}d||d<td|d|jd7_|jj|j|dd}zN||j}|t j krX|t j krQ|j dd}t |j d }|d krQ||krQ||fWStd |d |j vrftd |jd||j d }||fWSty~|w)zIAttempt to fetch a chunk from the end of the file with a negative offset.zbytes=-rzinitial bytes request: %srQTrrNrrqz*did not receive partial content: got code Content-Rangez%file length cannot be determined for z2, did not receive content range header from server)rr:r;rrrrrrrpartial_contentrrrNr$rrrr{)r.rrrcode accept_rangescontent_length file_lengthr!r!r"_try_initial_chunk_requestVs<       z,LazyWheelOverHTTP._try_initial_chunk_requesttuple[int, Response | None]c Cst|jj}||jvr|dfSz ||\}}WnQtyk}zE|j}|dur,|jnd}|t j krN|durNd|j vrN| |j d}|dfWYd}~St d|||j||dfWYd}~Sd}~wwt|j d|ks|j dddr|d}|j|||fS)zFGet the Content-Length of the remote file, and possibly a chunk of it.NrznNegative byte range not supported for domain '%s': using HEAD request before lazy wheel from now on (code: %s)rzbytes -)r rnetlocrrrrrrrrequested_range_not_satisfiablerrr:r;addrNr startswithr{)r.rdomainrrrAresprr!r!r"rsB      % z)LazyWheelOverHTTP._extract_content_lengthcCstd|d}d}t|}d}|D]!}|dur)|j|jr(|j}|j}qq|j|js5|j}nq|durItd|jd|d|j |durP|j }td|| ||td||S) aOLocate the *.dist-info/METADATA entry from a temporary ``ZipFile`` wrapper, and download it. This method assumes that the *.dist-info directory (containing e.g. METADATA) is contained in a single contiguous section of the zip file in order to ensure it can be downloaded in a single ranged GET request.z!begin prefetching METADATA for %sNrzno z found for z in zfetch z done prefetching METADATA for %s) r:r;r infolist_metadata_regexsearchr header_offsetr&r* start_dirr)r.r*rMrOrrinfor!r!r"rs4    z$LazyWheelOverHTTP._prefetch_metadataN)r*r)r+rqr)rr)r+rN)rrNr+r)rrNr+r)r*r)r+r))rrrr setr__annotations__rcompilerr7rrr staticmethodrrrrr!r!r!r"r6s     <  19r6)r*r)r3r)r4r5r+r):r __future__rrloggingrbisectrr contextlibrtempfilertypingrrr r urllib.parser zipfiler r packaging.metadatarrequests.modelsrrrrequests.status_codesrcollections.abcrrtypesrrrequestsrtyping_extensionsrpoetry.utils.authenticatorr getLoggerrr:r8rr$r%r&r'rBrCrqr]rr6r!r!r!r"sR                          -6sL