pip 25.1.1__py3-none-any.whl → 25.2__py3-none-any.whl

pip/_internal/models/wheel.py

@@ -2,8 +2,10 @@
 name that have meaning.
 """
 
+from __future__ import annotations
+
 import re
-from typing import Dict, Iterable, List, Optional
+from collections.abc import Iterable
 
 from pip._vendor.packaging.tags import Tag
 from pip._vendor.packaging.utils import BuildTag, parse_wheel_filename
@@ -31,7 +33,7 @@ class Wheel:
         # To make mypy happy specify type hints that can come from either
         # parse_wheel_filename or the legacy_wheel_file_re match.
         self.name: str
-        self._build_tag: Optional[BuildTag] = None
+        self._build_tag: BuildTag | None = None
 
         try:
             wheel_info = parse_wheel_filename(filename)
@@ -88,11 +90,11 @@ class Wheel:
 
         return self._build_tag
 
-    def get_formatted_file_tags(self) -> List[str]:
+    def get_formatted_file_tags(self) -> list[str]:
         """Return the wheel's tags as a sorted list of strings."""
         return sorted(str(tag) for tag in self.file_tags)
 
-    def support_index_min(self, tags: List[Tag]) -> int:
+    def support_index_min(self, tags: list[Tag]) -> int:
         """Return the lowest index that one of the wheel's file_tag combinations
         achieves in the given list of supported tags.
 
@@ -111,7 +113,7 @@ class Wheel:
             raise ValueError()
 
     def find_most_preferred_tag(
-        self, tags: List[Tag], tag_to_priority: Dict[Tag, int]
+        self, tags: list[Tag], tag_to_priority: dict[Tag, int]
     ) -> int:
         """Return the priority of the most preferred tag that one of the wheel's file
         tag combinations achieves in the given list of supported tags using the given

pip/_internal/network/auth.py

@@ -4,6 +4,8 @@ Contains interface (MultiDomainBasicAuth) and associated glue code for
 providing credentials in the context of network requests.
 """
 
+from __future__ import annotations
+
 import logging
 import os
 import shutil
@@ -12,10 +14,10 @@ import sysconfig
 import typing
 import urllib.parse
 from abc import ABC, abstractmethod
-from functools import lru_cache
+from functools import cache
 from os.path import commonprefix
 from pathlib import Path
-from typing import Any, Dict, List, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple
 
 from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth
 from pip._vendor.requests.models import Request, Response
@@ -48,9 +50,7 @@ class KeyRingBaseProvider(ABC):
     has_keyring: bool
 
     @abstractmethod
-    def get_auth_info(
-        self, url: str, username: Optional[str]
-    ) -> Optional[AuthInfo]: ...
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None: ...
 
     @abstractmethod
     def save_auth_info(self, url: str, username: str, password: str) -> None: ...
@@ -61,7 +61,7 @@ class KeyRingNullProvider(KeyRingBaseProvider):
 
     has_keyring = False
 
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None:
         return None
 
     def save_auth_info(self, url: str, username: str, password: str) -> None:
@@ -78,7 +78,7 @@ class KeyRingPythonProvider(KeyRingBaseProvider):
 
         self.keyring = keyring
 
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None:
         # Support keyring's get_credential interface which supports getting
         # credentials without a username. This is only available for
         # keyring>=15.2.0.
@@ -114,7 +114,7 @@ class KeyRingCliProvider(KeyRingBaseProvider):
     def __init__(self, cmd: str) -> None:
         self.keyring = cmd
 
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None:
         # This is the default implementation of keyring.get_credential
         # https://github.com/jaraco/keyring/blob/97689324abcf01bd1793d49063e7ca01e03d7d07/keyring/backend.py#L134-L139
         if username is not None:
@@ -126,7 +126,7 @@ class KeyRingCliProvider(KeyRingBaseProvider):
     def save_auth_info(self, url: str, username: str, password: str) -> None:
         return self._set_password(url, username, password)
 
-    def _get_password(self, service_name: str, username: str) -> Optional[str]:
+    def _get_password(self, service_name: str, username: str) -> str | None:
         """Mirror the implementation of keyring.get_password using cli"""
         if self.keyring is None:
             return None
@@ -159,7 +159,7 @@ class KeyRingCliProvider(KeyRingBaseProvider):
         return None
 
 
-@lru_cache(maxsize=None)
+@cache
 def get_keyring_provider(provider: str) -> KeyRingBaseProvider:
     logger.verbose("Keyring provider requested: %s", provider)
 
@@ -225,19 +225,19 @@ class MultiDomainBasicAuth(AuthBase):
     def __init__(
         self,
         prompting: bool = True,
-        index_urls: Optional[List[str]] = None,
+        index_urls: list[str] | None = None,
         keyring_provider: str = "auto",
     ) -> None:
         self.prompting = prompting
         self.index_urls = index_urls
-        self.keyring_provider = keyring_provider  # type: ignore[assignment]
-        self.passwords: Dict[str, AuthInfo] = {}
+        self.keyring_provider = keyring_provider
+        self.passwords: dict[str, AuthInfo] = {}
         # When the user is prompted to enter credentials and keyring is
         # available, we will offer to save them. If the user accepts,
         # this value is set to the credentials they entered. After the
         # request authenticates, the caller should call
         # ``save_credentials`` to save these.
-        self._credentials_to_save: Optional[Credentials] = None
+        self._credentials_to_save: Credentials | None = None
 
     @property
     def keyring_provider(self) -> KeyRingBaseProvider:
@@ -260,9 +260,9 @@ class MultiDomainBasicAuth(AuthBase):
 
     def _get_keyring_auth(
         self,
-        url: Optional[str],
-        username: Optional[str],
-    ) -> Optional[AuthInfo]:
+        url: str | None,
+        username: str | None,
+    ) -> AuthInfo | None:
         """Return the tuple auth for a given url from keyring."""
         # Do nothing if no url was provided
         if not url:
@@ -284,7 +284,7 @@ class MultiDomainBasicAuth(AuthBase):
             get_keyring_provider.cache_clear()
             return None
 
-    def _get_index_url(self, url: str) -> Optional[str]:
+    def _get_index_url(self, url: str) -> str | None:
         """Return the original index URL matching the requested URL.
 
         Cached or dynamically generated credentials may work against
@@ -391,7 +391,7 @@ class MultiDomainBasicAuth(AuthBase):
 
     def _get_url_and_credentials(
         self, original_url: str
-    ) -> Tuple[str, Optional[str], Optional[str]]:
+    ) -> tuple[str, str | None, str | None]:
         """Return the credentials to use for the provided URL.
 
         If allowed, netrc and keyring may be used to obtain the
@@ -454,9 +454,7 @@ class MultiDomainBasicAuth(AuthBase):
         return req
 
     # Factored out to allow for easy patching in tests
-    def _prompt_for_password(
-        self, netloc: str
-    ) -> Tuple[Optional[str], Optional[str], bool]:
+    def _prompt_for_password(self, netloc: str) -> tuple[str | None, str | None, bool]:
         username = ask_input(f"User for {netloc}: ") if self.prompting else None
         if not username:
             return None, None, False

pip/_internal/network/cache.py

@@ -1,9 +1,13 @@
 """HTTP cache implementation."""
 
+from __future__ import annotations
+
 import os
+import shutil
+from collections.abc import Generator
 from contextlib import contextmanager
 from datetime import datetime
-from typing import BinaryIO, Generator, Optional, Union
+from typing import Any, BinaryIO, Callable
 
 from pip._vendor.cachecontrol.cache import SeparateBodyBaseCache
 from pip._vendor.cachecontrol.caches import SeparateBodyFileCache
@@ -59,7 +63,7 @@ class SafeFileCache(SeparateBodyBaseCache):
         parts = list(hashed[:5]) + [hashed]
         return os.path.join(self.directory, *parts)
 
-    def get(self, key: str) -> Optional[bytes]:
+    def get(self, key: str) -> bytes | None:
         # The cache entry is only valid if both metadata and body exist.
         metadata_path = self._get_cache_path(key)
         body_path = metadata_path + ".body"
@@ -69,12 +73,13 @@ class SafeFileCache(SeparateBodyBaseCache):
             with open(metadata_path, "rb") as f:
                 return f.read()
 
-    def _write(self, path: str, data: bytes) -> None:
+    def _write_to_file(self, path: str, writer_func: Callable[[BinaryIO], Any]) -> None:
+        """Common file writing logic with proper permissions and atomic replacement."""
         with suppressed_cache_errors():
             ensure_dir(os.path.dirname(path))
 
             with adjacent_tmp_file(path) as f:
-                f.write(data)
+                writer_func(f)
                 # Inherit the read/write permissions of the cache directory
                 # to enable multi-user cache use-cases.
                 mode = (
@@ -90,8 +95,14 @@ class SafeFileCache(SeparateBodyBaseCache):
 
             replace(f.name, path)
 
+    def _write(self, path: str, data: bytes) -> None:
+        self._write_to_file(path, lambda f: f.write(data))
+
+    def _write_from_io(self, path: str, source_file: BinaryIO) -> None:
+        self._write_to_file(path, lambda f: shutil.copyfileobj(source_file, f))
+
     def set(
-        self, key: str, value: bytes, expires: Union[int, datetime, None] = None
+        self, key: str, value: bytes, expires: int | datetime | None = None
     ) -> None:
         path = self._get_cache_path(key)
         self._write(path, value)
@@ -103,7 +114,7 @@ class SafeFileCache(SeparateBodyBaseCache):
         with suppressed_cache_errors():
             os.remove(path + ".body")
 
-    def get_body(self, key: str) -> Optional[BinaryIO]:
+    def get_body(self, key: str) -> BinaryIO | None:
         # The cache entry is only valid if both metadata and body exist.
         metadata_path = self._get_cache_path(key)
         body_path = metadata_path + ".body"
@@ -115,3 +126,8 @@ class SafeFileCache(SeparateBodyBaseCache):
     def set_body(self, key: str, body: bytes) -> None:
         path = self._get_cache_path(key) + ".body"
         self._write(path, body)
+
+    def set_body_from_io(self, key: str, body_file: BinaryIO) -> None:
+        """Set the body of the cache entry from a file object."""
+        path = self._get_cache_path(key) + ".body"
+        self._write_from_io(path, body_file)

pip/_internal/network/download.py

@@ -1,35 +1,42 @@
 """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, Iterable, Optional, Tuple
+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 get_download_progress_renderer
+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 is_from_cache
-from pip._internal.network.session import PipSession
+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) -> Optional[int]:
+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) -> Optional[str]:
+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.
@@ -37,12 +44,12 @@ def _get_http_response_etag_or_last_modified(resp: Response) -> Optional[str]:
     return resp.headers.get("etag", resp.headers.get("last-modified"))
 
 
-def _prepare_download(
+def _log_download(
     resp: Response,
     link: Link,
-    progress_bar: str,
-    total_length: Optional[int],
-    range_start: Optional[int] = 0,
+    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
@@ -119,7 +126,7 @@ def _get_http_response_filename(resp: Response, link: Link) -> str:
     content_disposition = resp.headers.get("content-disposition")
     if content_disposition:
         filename = parse_content_disposition(content_disposition, filename)
-    ext: Optional[str] = splitext(filename)[1]
+    ext: str | None = splitext(filename)[1]
     if not ext:
         ext = mimetypes.guess_extension(resp.headers.get("content-type", ""))
         if ext:
@@ -131,35 +138,35 @@ def _get_http_response_filename(resp: Response, link: Link) -> str:
     return filename
 
 
-def _http_get_download(
-    session: PipSession,
-    link: Link,
-    range_start: Optional[int] = 0,
-    if_range: Optional[str] = None,
-) -> Response:
-    target_url = link.url.split("#", 1)[0]
-    headers = HEADERS.copy()
-    # request a partial download
-    if range_start:
-        headers["Range"] = f"bytes={range_start}-"
-    # make sure the file hasn't changed
-    if if_range:
-        headers["If-Range"] = if_range
-    try:
-        resp = 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
+@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: str,
+        progress_bar: BarType,
         resume_retries: int,
     ) -> None:
         assert (
@@ -169,146 +176,167 @@ class Downloader:
         self._progress_bar = progress_bar
         self._resume_retries = resume_retries
 
-    def __call__(self, link: Link, location: str) -> Tuple[str, str]:
-        """Download the file given by link into location."""
-        resp = _http_get_download(self._session, link)
-        # NOTE: The original download size needs to be passed down everywhere
-        # so if the download is resumed (with a HTTP Range request) the progress
-        # bar will report the right size.
-        total_length = _get_http_response_size(resp)
-        content_type = resp.headers.get("Content-Type", "")
+    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)
 
-        filename = _get_http_response_filename(resp, link)
-        filepath = os.path.join(location, filename)
+    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:
-            bytes_received = self._process_response(
-                resp, link, content_file, 0, total_length
-            )
-            # If possible, check for an incomplete download and attempt resuming.
-            if total_length and bytes_received < total_length:
-                self._attempt_resume(
-                    resp, link, content_file, total_length, bytes_received
-                )
+            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,
-        resp: Response,
-        link: Link,
-        content_file: BinaryIO,
-        bytes_received: int,
-        total_length: Optional[int],
-    ) -> int:
-        """Process the response and write the chunks to the file."""
-        chunks = _prepare_download(
-            resp, link, self._progress_bar, total_length, range_start=bytes_received
-        )
-        return self._write_chunks_to_file(
-            chunks, content_file, allow_partial=bool(total_length)
+    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,
         )
-
-    def _write_chunks_to_file(
-        self, chunks: Iterable[bytes], content_file: BinaryIO, *, allow_partial: bool
-    ) -> int:
-        """Write the chunks to the file and return the number of bytes received."""
-        bytes_received = 0
         try:
             for chunk in chunks:
-                bytes_received += len(chunk)
-                content_file.write(chunk)
+                download.write_chunk(chunk)
         except ReadTimeoutError as e:
-            # If partial downloads are OK (the download will be retried), don't bail.
-            if not allow_partial:
+            # If the download size is not known, then give up downloading the file.
+            if download.size is None:
                 raise e
 
-            # Ensuring bytes_received is returned to attempt resume
             logger.warning("Connection timed out while downloading.")
 
-        return bytes_received
-
-    def _attempt_resume(
-        self,
-        resp: Response,
-        link: Link,
-        content_file: BinaryIO,
-        total_length: Optional[int],
-        bytes_received: int,
+    def _attempt_resumes_or_redownloads(
+        self, download: _FileDownload, first_resp: Response
     ) -> None:
-        """Attempt to resume the download if connection was dropped."""
-        etag_or_last_modified = _get_http_response_etag_or_last_modified(resp)
-
-        attempts_left = self._resume_retries
-        while total_length and attempts_left and bytes_received < total_length:
-            attempts_left -= 1
+        """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(bytes_received),
-                format_size(total_length),
-                (self._resume_retries - attempts_left),
+                format_size(download.bytes_received),
+                format_size(download.size),
+                download.reattempts,
             )
 
             try:
-                # Try to resume the download using a HTTP range request.
-                resume_resp = _http_get_download(
-                    self._session,
-                    link,
-                    range_start=bytes_received,
-                    if_range=etag_or_last_modified,
-                )
-
+                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:
-                    bytes_received, total_length, etag_or_last_modified = (
-                        self._reset_download_state(resume_resp, content_file)
-                    )
+                    download.reset_file()
+                    download.size = _get_http_response_size(resume_resp)
+                    first_resp = resume_resp
 
-                bytes_received += self._process_response(
-                    resume_resp, link, content_file, bytes_received, total_length
-                )
+                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 total_length and bytes_received < total_length:
-            os.remove(content_file.name)
-            raise IncompleteDownloadError(
-                link, bytes_received, total_length, retries=self._resume_retries
-            )
+        if download.is_incomplete():
+            os.remove(download.output_file.name)
+            raise IncompleteDownloadError(download)
 
-    def _reset_download_state(
-        self,
-        resp: Response,
-        content_file: BinaryIO,
-    ) -> Tuple[int, Optional[int], Optional[str]]:
-        """Reset the download state to restart downloading from the beginning."""
-        content_file.seek(0)
-        content_file.truncate()
-        bytes_received = 0
-        total_length = _get_http_response_size(resp)
-        etag_or_last_modified = _get_http_response_etag_or_last_modified(resp)
+        # 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)
 
-        return bytes_received, total_length, etag_or_last_modified
+    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)
 
-class BatchDownloader:
-    def __init__(
-        self,
-        session: PipSession,
-        progress_bar: str,
-        resume_retries: int,
-    ) -> None:
-        self._downloader = Downloader(session, progress_bar, resume_retries)
+        logger.debug(
+            "Cached resumed download as complete response for future use: %s", url
+        )
 
-    def __call__(
-        self, links: Iterable[Link], location: str
-    ) -> Iterable[Tuple[Link, Tuple[str, str]]]:
-        """Download the files given by links into location."""
-        for link in links:
-            filepath, content_type = self._downloader(link, location)
-            yield link, (filepath, content_type)
+    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