cli-ih 0.6.3.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

venv/Lib/site-packages/pip/_internal/network/download.py

@@ -1,342 +0,0 @@
-"""Download files with progress indicators."""
-
-from __future__ import annotations
-
-import email.message
-import logging
-import mimetypes
-import os
-from collections.abc import Iterable, Mapping
-from dataclasses import dataclass
-from http import HTTPStatus
-from typing import BinaryIO
-
-from pip._vendor.requests import PreparedRequest
-from pip._vendor.requests.models import Response
-from pip._vendor.urllib3 import HTTPResponse as URLlib3Response
-from pip._vendor.urllib3._collections import HTTPHeaderDict
-from pip._vendor.urllib3.exceptions import ReadTimeoutError
-
-from pip._internal.cli.progress_bars import BarType, get_download_progress_renderer
-from pip._internal.exceptions import IncompleteDownloadError, NetworkConnectionError
-from pip._internal.models.index import PyPI
-from pip._internal.models.link import Link
-from pip._internal.network.cache import SafeFileCache, is_from_cache
-from pip._internal.network.session import CacheControlAdapter, PipSession
-from pip._internal.network.utils import HEADERS, raise_for_status, response_chunks
-from pip._internal.utils.misc import format_size, redact_auth_from_url, splitext
-
-logger = logging.getLogger(__name__)
-
-
-def _get_http_response_size(resp: Response) -> int | None:
-    try:
-        return int(resp.headers["content-length"])
-    except (ValueError, KeyError, TypeError):
-        return None
-
-
-def _get_http_response_etag_or_last_modified(resp: Response) -> str | None:
-    """
-    Return either the ETag or Last-Modified header (or None if neither exists).
-    The return value can be used in an If-Range header.
-    """
-    return resp.headers.get("etag", resp.headers.get("last-modified"))
-
-
-def _log_download(
-    resp: Response,
-    link: Link,
-    progress_bar: BarType,
-    total_length: int | None,
-    range_start: int | None = 0,
-) -> Iterable[bytes]:
-    if link.netloc == PyPI.file_storage_domain:
-        url = link.show_url
-    else:
-        url = link.url_without_fragment
-
-    logged_url = redact_auth_from_url(url)
-
-    if total_length:
-        if range_start:
-            logged_url = (
-                f"{logged_url} ({format_size(range_start)}/{format_size(total_length)})"
-            )
-        else:
-            logged_url = f"{logged_url} ({format_size(total_length)})"
-
-    if is_from_cache(resp):
-        logger.info("Using cached %s", logged_url)
-    elif range_start:
-        logger.info("Resuming download %s", logged_url)
-    else:
-        logger.info("Downloading %s", logged_url)
-
-    if logger.getEffectiveLevel() > logging.INFO:
-        show_progress = False
-    elif is_from_cache(resp):
-        show_progress = False
-    elif not total_length:
-        show_progress = True
-    elif total_length > (512 * 1024):
-        show_progress = True
-    else:
-        show_progress = False
-
-    chunks = response_chunks(resp)
-
-    if not show_progress:
-        return chunks
-
-    renderer = get_download_progress_renderer(
-        bar_type=progress_bar, size=total_length, initial_progress=range_start
-    )
-    return renderer(chunks)
-
-
-def sanitize_content_filename(filename: str) -> str:
-    """
-    Sanitize the "filename" value from a Content-Disposition header.
-    """
-    return os.path.basename(filename)
-
-
-def parse_content_disposition(content_disposition: str, default_filename: str) -> str:
-    """
-    Parse the "filename" value from a Content-Disposition header, and
-    return the default filename if the result is empty.
-    """
-    m = email.message.Message()
-    m["content-type"] = content_disposition
-    filename = m.get_param("filename")
-    if filename:
-        # We need to sanitize the filename to prevent directory traversal
-        # in case the filename contains ".." path parts.
-        filename = sanitize_content_filename(str(filename))
-    return filename or default_filename
-
-
-def _get_http_response_filename(resp: Response, link: Link) -> str:
-    """Get an ideal filename from the given HTTP response, falling back to
-    the link filename if not provided.
-    """
-    filename = link.filename  # fallback
-    # Have a look at the Content-Disposition header for a better guess
-    content_disposition = resp.headers.get("content-disposition")
-    if content_disposition:
-        filename = parse_content_disposition(content_disposition, filename)
-    ext: str | None = splitext(filename)[1]
-    if not ext:
-        ext = mimetypes.guess_extension(resp.headers.get("content-type", ""))
-        if ext:
-            filename += ext
-    if not ext and link.url != resp.url:
-        ext = os.path.splitext(resp.url)[1]
-        if ext:
-            filename += ext
-    return filename
-
-
-@dataclass
-class _FileDownload:
-    """Stores the state of a single link download."""
-
-    link: Link
-    output_file: BinaryIO
-    size: int | None
-    bytes_received: int = 0
-    reattempts: int = 0
-
-    def is_incomplete(self) -> bool:
-        return bool(self.size is not None and self.bytes_received < self.size)
-
-    def write_chunk(self, data: bytes) -> None:
-        self.bytes_received += len(data)
-        self.output_file.write(data)
-
-    def reset_file(self) -> None:
-        """Delete any saved data and reset progress to zero."""
-        self.output_file.seek(0)
-        self.output_file.truncate()
-        self.bytes_received = 0
-
-
-class Downloader:
-    def __init__(
-        self,
-        session: PipSession,
-        progress_bar: BarType,
-        resume_retries: int,
-    ) -> None:
-        assert (
-            resume_retries >= 0
-        ), "Number of max resume retries must be bigger or equal to zero"
-        self._session = session
-        self._progress_bar = progress_bar
-        self._resume_retries = resume_retries
-
-    def batch(
-        self, links: Iterable[Link], location: str
-    ) -> Iterable[tuple[Link, tuple[str, str]]]:
-        """Convenience method to download multiple links."""
-        for link in links:
-            filepath, content_type = self(link, location)
-            yield link, (filepath, content_type)
-
-    def __call__(self, link: Link, location: str) -> tuple[str, str]:
-        """Download a link and save it under location."""
-        resp = self._http_get(link)
-        download_size = _get_http_response_size(resp)
-
-        filepath = os.path.join(location, _get_http_response_filename(resp, link))
-        with open(filepath, "wb") as content_file:
-            download = _FileDownload(link, content_file, download_size)
-            self._process_response(download, resp)
-            if download.is_incomplete():
-                self._attempt_resumes_or_redownloads(download, resp)
-
-        content_type = resp.headers.get("Content-Type", "")
-        return filepath, content_type
-
-    def _process_response(self, download: _FileDownload, resp: Response) -> None:
-        """Download and save chunks from a response."""
-        chunks = _log_download(
-            resp,
-            download.link,
-            self._progress_bar,
-            download.size,
-            range_start=download.bytes_received,
-        )
-        try:
-            for chunk in chunks:
-                download.write_chunk(chunk)
-        except ReadTimeoutError as e:
-            # If the download size is not known, then give up downloading the file.
-            if download.size is None:
-                raise e
-
-            logger.warning("Connection timed out while downloading.")
-
-    def _attempt_resumes_or_redownloads(
-        self, download: _FileDownload, first_resp: Response
-    ) -> None:
-        """Attempt to resume/restart the download if connection was dropped."""
-
-        while download.reattempts < self._resume_retries and download.is_incomplete():
-            assert download.size is not None
-            download.reattempts += 1
-            logger.warning(
-                "Attempting to resume incomplete download (%s/%s, attempt %d)",
-                format_size(download.bytes_received),
-                format_size(download.size),
-                download.reattempts,
-            )
-
-            try:
-                resume_resp = self._http_get_resume(download, should_match=first_resp)
-                # Fallback: if the server responded with 200 (i.e., the file has
-                # since been modified or range requests are unsupported) or any
-                # other unexpected status, restart the download from the beginning.
-                must_restart = resume_resp.status_code != HTTPStatus.PARTIAL_CONTENT
-                if must_restart:
-                    download.reset_file()
-                    download.size = _get_http_response_size(resume_resp)
-                    first_resp = resume_resp
-
-                self._process_response(download, resume_resp)
-            except (ConnectionError, ReadTimeoutError, OSError):
-                continue
-
-        # No more resume attempts. Raise an error if the download is still incomplete.
-        if download.is_incomplete():
-            os.remove(download.output_file.name)
-            raise IncompleteDownloadError(download)
-
-        # If we successfully completed the download via resume, manually cache it
-        # as a complete response to enable future caching
-        if download.reattempts > 0:
-            self._cache_resumed_download(download, first_resp)
-
-    def _cache_resumed_download(
-        self, download: _FileDownload, original_response: Response
-    ) -> None:
-        """
-        Manually cache a file that was successfully downloaded via resume retries.
-
-        cachecontrol doesn't cache 206 (Partial Content) responses, since they
-        are not complete files. This method manually adds the final file to the
-        cache as though it was downloaded in a single request, so that future
-        requests can use the cache.
-        """
-        url = download.link.url_without_fragment
-        adapter = self._session.get_adapter(url)
-
-        # Check if the adapter is the CacheControlAdapter (i.e. caching is enabled)
-        if not isinstance(adapter, CacheControlAdapter):
-            logger.debug(
-                "Skipping resume download caching: no cache controller for %s", url
-            )
-            return
-
-        # Check SafeFileCache is being used
-        assert isinstance(
-            adapter.cache, SafeFileCache
-        ), "separate body cache not in use!"
-
-        synthetic_request = PreparedRequest()
-        synthetic_request.prepare(method="GET", url=url, headers={})
-
-        synthetic_response_headers = HTTPHeaderDict()
-        for key, value in original_response.headers.items():
-            if key.lower() not in ["content-range", "content-length"]:
-                synthetic_response_headers[key] = value
-        synthetic_response_headers["content-length"] = str(download.size)
-
-        synthetic_response = URLlib3Response(
-            body="",
-            headers=synthetic_response_headers,
-            status=200,
-            preload_content=False,
-        )
-
-        # Save metadata and then stream the file contents to cache.
-        cache_url = adapter.controller.cache_url(url)
-        metadata_blob = adapter.controller.serializer.dumps(
-            synthetic_request, synthetic_response, b""
-        )
-        adapter.cache.set(cache_url, metadata_blob)
-        download.output_file.flush()
-        with open(download.output_file.name, "rb") as f:
-            adapter.cache.set_body_from_io(cache_url, f)
-
-        logger.debug(
-            "Cached resumed download as complete response for future use: %s", url
-        )
-
-    def _http_get_resume(
-        self, download: _FileDownload, should_match: Response
-    ) -> Response:
-        """Issue a HTTP range request to resume the download."""
-        # To better understand the download resumption logic, see the mdn web docs:
-        # https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Range_requests
-        headers = HEADERS.copy()
-        headers["Range"] = f"bytes={download.bytes_received}-"
-        # If possible, use a conditional range request to avoid corrupted
-        # downloads caused by the remote file changing in-between.
-        if identifier := _get_http_response_etag_or_last_modified(should_match):
-            headers["If-Range"] = identifier
-        return self._http_get(download.link, headers)
-
-    def _http_get(self, link: Link, headers: Mapping[str, str] = HEADERS) -> Response:
-        target_url = link.url_without_fragment
-        try:
-            resp = self._session.get(target_url, headers=headers, stream=True)
-            raise_for_status(resp)
-        except NetworkConnectionError as e:
-            assert e.response is not None
-            logger.critical(
-                "HTTP error %s while getting %s", e.response.status_code, link
-            )
-            raise
-        return resp

venv/Lib/site-packages/pip/_internal/network/lazy_wheel.py

@@ -1,213 +0,0 @@
-"""Lazy ZIP over HTTP"""
-
-from __future__ import annotations
-
-__all__ = ["HTTPRangeRequestUnsupported", "dist_from_wheel_url"]
-
-from bisect import bisect_left, bisect_right
-from collections.abc import Generator
-from contextlib import contextmanager
-from tempfile import NamedTemporaryFile
-from typing import Any
-from zipfile import BadZipFile, ZipFile
-
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.requests.models import CONTENT_CHUNK_SIZE, Response
-
-from pip._internal.metadata import BaseDistribution, MemoryWheel, get_wheel_distribution
-from pip._internal.network.session import PipSession
-from pip._internal.network.utils import HEADERS, raise_for_status, response_chunks
-
-
-class HTTPRangeRequestUnsupported(Exception):
-    pass
-
-
-def dist_from_wheel_url(name: str, url: str, session: PipSession) -> BaseDistribution:
-    """Return a distribution object 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.
-    If such requests are not supported, HTTPRangeRequestUnsupported
-    is raised.
-    """
-    with LazyZipOverHTTP(url, session) as zf:
-        # For read-only ZIP files, ZipFile only needs methods read,
-        # seek, seekable and tell, not the whole IO protocol.
-        wheel = MemoryWheel(zf.name, zf)  # type: ignore
-        # After context manager exit, wheel.name
-        # is an invalid file by intention.
-        return get_wheel_distribution(wheel, canonicalize_name(name))
-
-
-class LazyZipOverHTTP:
-    """File-like object mapped to a ZIP file over HTTP.
-
-    This uses HTTP range requests to lazily fetch the file's content,
-    which is supposed to be fed to ZipFile.  If such requests are not
-    supported by the server, raise HTTPRangeRequestUnsupported
-    during initialization.
-    """
-
-    def __init__(
-        self, url: str, session: PipSession, chunk_size: int = CONTENT_CHUNK_SIZE
-    ) -> None:
-        head = session.head(url, headers=HEADERS)
-        raise_for_status(head)
-        assert head.status_code == 200
-        self._session, self._url, self._chunk_size = session, url, chunk_size
-        self._length = int(head.headers["Content-Length"])
-        self._file = NamedTemporaryFile()
-        self.truncate(self._length)
-        self._left: list[int] = []
-        self._right: list[int] = []
-        if "bytes" not in head.headers.get("Accept-Ranges", "none"):
-            raise HTTPRangeRequestUnsupported("range request is not supported")
-        self._check_zip()
-
-    @property
-    def mode(self) -> str:
-        """Opening mode, which is always rb."""
-        return "rb"
-
-    @property
-    def name(self) -> str:
-        """Path to the underlying file."""
-        return self._file.name
-
-    def seekable(self) -> bool:
-        """Return whether random access is supported, which is True."""
-        return True
-
-    def close(self) -> None:
-        """Close the file."""
-        self._file.close()
-
-    @property
-    def closed(self) -> bool:
-        """Whether the file is closed."""
-        return self._file.closed
-
-    def read(self, size: int = -1) -> bytes:
-        """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.
-        """
-        download_size = max(size, self._chunk_size)
-        start, length = self.tell(), self._length
-        stop = length if size < 0 else min(start + download_size, length)
-        start = max(0, stop - download_size)
-        self._download(start, stop - 1)
-        return self._file.read(size)
-
-    def readable(self) -> bool:
-        """Return whether the file is readable, which is True."""
-        return True
-
-    def seek(self, offset: int, whence: int = 0) -> int:
-        """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.
-        """
-        return self._file.seek(offset, whence)
-
-    def tell(self) -> int:
-        """Return the current position."""
-        return self._file.tell()
-
-    def truncate(self, size: int | None = None) -> int:
-        """Resize 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.
-        """
-        return self._file.truncate(size)
-
-    def writable(self) -> bool:
-        """Return False."""
-        return False
-
-    def __enter__(self) -> LazyZipOverHTTP:
-        self._file.__enter__()
-        return self
-
-    def __exit__(self, *exc: Any) -> None:
-        self._file.__exit__(*exc)
-
-    @contextmanager
-    def _stay(self) -> Generator[None, None, None]:
-        """Return a context manager keeping the position.
-
-        At the end of the block, seek back to original position.
-        """
-        pos = self.tell()
-        try:
-            yield
-        finally:
-            self.seek(pos)
-
-    def _check_zip(self) -> None:
-        """Check and download until the file is a valid ZIP."""
-        end = self._length - 1
-        for start in reversed(range(0, end, self._chunk_size)):
-            self._download(start, end)
-            with self._stay():
-                try:
-                    # For read-only ZIP files, ZipFile only needs
-                    # methods read, seek, seekable and tell.
-                    ZipFile(self)
-                except BadZipFile:
-                    pass
-                else:
-                    break
-
-    def _stream_response(
-        self, start: int, end: int, base_headers: dict[str, str] = HEADERS
-    ) -> Response:
-        """Return HTTP response to a range request from start to end."""
-        headers = base_headers.copy()
-        headers["Range"] = f"bytes={start}-{end}"
-        # TODO: Get range requests to be correctly cached
-        headers["Cache-Control"] = "no-cache"
-        return self._session.get(self._url, headers=headers, stream=True)
-
-    def _merge(
-        self, start: int, end: int, left: int, right: int
-    ) -> Generator[tuple[int, int], None, None]:
-        """Return a generator of intervals to be fetched.
-
-        Args:
-            start (int): Start of needed interval
-            end (int): End of needed interval
-            left (int): Index of first overlapping downloaded data
-            right (int): Index after last overlapping downloaded data
-        """
-        lslice, rslice = self._left[left:right], self._right[left:right]
-        i = start = min([start] + lslice[:1])
-        end = max([end] + rslice[-1:])
-        for j, k in zip(lslice, rslice):
-            if j > i:
-                yield i, j - 1
-            i = k + 1
-        if i <= end:
-            yield i, end
-        self._left[left:right], self._right[left:right] = [start], [end]
-
-    def _download(self, start: int, end: int) -> None:
-        """Download bytes from start to end inclusively."""
-        with self._stay():
-            left = bisect_left(self._right, start)
-            right = bisect_right(self._left, end)
-            for start, end in self._merge(start, end, left, right):
-                response = self._stream_response(start, end)
-                response.raise_for_status()
-                self.seek(start)
-                for chunk in response_chunks(response, self._chunk_size):
-                    self._file.write(chunk)