RequirementPreparer Class Reference

Public Member Functions
None	__init__ (self, str build_dir, Optional[str] download_dir, str src_dir, bool build_isolation, bool check_build_deps, BuildTracker build_tracker, PipSession session, str progress_bar, PackageFinder finder, bool require_hashes, bool use_user_site, bool lazy_wheel, int verbosity, bool legacy_resolver)
BaseDistribution	prepare_linked_requirement (self, InstallRequirement req, bool parallel_builds=False)
None	prepare_linked_requirements_more (self, Iterable[InstallRequirement] reqs, bool parallel_builds=False)
None	save_linked_requirement (self, InstallRequirement req)
BaseDistribution	prepare_editable_requirement (self, InstallRequirement req)
BaseDistribution	prepare_installed_requirement (self, InstallRequirement req, str skip_reason)

Data Fields
	src_dir
	build_dir
	build_tracker
	finder
	download_dir
	build_isolation
	check_build_deps
	require_hashes
	use_user_site
	use_lazy_wheel
	verbosity
	legacy_resolver

Protected Member Functions
None	_log_preparing_link (self, InstallRequirement req)
None	_ensure_link_req_src_dir (self, InstallRequirement req, bool parallel_builds)
Hashes	_get_linked_req_hashes (self, InstallRequirement req)
Optional[BaseDistribution]	_fetch_metadata_only (self, InstallRequirement req)
Optional[BaseDistribution]	_fetch_metadata_using_link_data_attr (self, InstallRequirement req)
Optional[BaseDistribution]	_fetch_metadata_using_lazy_wheel (self, Link link)
None	_complete_partial_requirements (self, Iterable[InstallRequirement] partially_downloaded_reqs, bool parallel_builds=False)
BaseDistribution	_prepare_linked_requirement (self, InstallRequirement req, bool parallel_builds)

Protected Attributes
	_session
	_download
	_batch_download
	_previous_requirement_header

Detailed Description

Prepares a Requirement

Definition at line 211 of file prepare.py.

Constructor & Destructor Documentation

__init__()

None __init__	(		self,
		str	build_dir,
		Optional[str]	download_dir,
		str	src_dir,
		bool	build_isolation,
		bool	check_build_deps,
		BuildTracker	build_tracker,
		PipSession	session,
		str	progress_bar,
		PackageFinder	finder,
		bool	require_hashes,
		bool	use_user_site,
		bool	lazy_wheel,
		int	verbosity,
		bool	legacy_resolver
	)

Definition at line 214 of file prepare.py.

    ) -> None:
        super().__init__()
 
        self.src_dir = src_dir
        self.build_dir = build_dir
        self.build_tracker = build_tracker
        self._session = session
        self._download = Downloader(session, progress_bar)
        self._batch_download = BatchDownloader(session, progress_bar)
        self.finder = finder
 
        # Where still-packed archives should be written to. If None, they are
        # not saved, and are deleted immediately after unpacking.
        self.download_dir = download_dir
 
        # Is build isolation allowed?
        self.build_isolation = build_isolation
 
        # Should check build dependencies?
        self.check_build_deps = check_build_deps
 
        # Should hash-checking be required?
        self.require_hashes = require_hashes
 
        # Should install in user site-packages?
        self.use_user_site = use_user_site
 
        # Should wheels be downloaded lazily?
        self.use_lazy_wheel = lazy_wheel
 
        # How verbose should underlying tooling be?
        self.verbosity = verbosity
 
        # Are we using the legacy resolver?
        self.legacy_resolver = legacy_resolver
 
        # Memoized downloaded files, as mapping of url: path.
        self._downloaded: Dict[str, str] = {}
 
        # Previous "header" printed for a link-based InstallRequirement
        self._previous_requirement_header = ("", "")
 

References RequirementPreparer.__init__(), and i.

Referenced by RequirementPreparer.__init__(), and Protocol.__init_subclass__().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

_complete_partial_requirements()

None _complete_partial_requirements (   self, Iterable[InstallRequirement]  partially_downloaded_reqs, bool   parallel_builds = False  )

protected

Download any requirements which were only fetched by metadata.

Definition at line 457 of file prepare.py.

    ) -> None:
        """Download any requirements which were only fetched by metadata."""
        # Download to a temporary directory. These will be copied over as
        # needed for downstream 'download', 'wheel', and 'install' commands.
        temp_dir = TempDirectory(kind="unpack", globally_managed=True).path
 
        # Map each link to the requirement that owns it. This allows us to set
        # `req.local_file_path` on the appropriate requirement after passing
        # all the links at once into BatchDownloader.
        links_to_fully_download: Dict[Link, InstallRequirement] = {}
        for req in partially_downloaded_reqs:
            assert req.link
            links_to_fully_download[req.link] = req
 
        batch_download = self._batch_download(
            links_to_fully_download.keys(),
            temp_dir,
        )
        for link, (filepath, _) in batch_download:
            logger.debug("Downloading link %s to %s", link, filepath)
            req = links_to_fully_download[link]
            req.local_file_path = filepath
            # TODO: This needs fixing for sdists
            # This is an emergency fix for #11847, which reports that
            # distributions get downloaded twice when metadata is loaded
            # from a PEP 658 standalone metadata file. Setting _downloaded
            # fixes this for wheels, but breaks the sdist case (tests
            # test_download_metadata). As PyPI is currently only serving
            # metadata for wheels, this is not an immediate issue.
            # Fixing the problem properly looks like it will require a
            # complete refactoring of the `prepare_linked_requirements_more`
            # logic, and I haven't a clue where to start on that, so for now
            # I have fixed the issue *just* for wheels.
            if req.is_wheel:
                self._downloaded[req.link.url] = filepath
 
        # This step is necessary to ensure all lazy wheels are processed
        # successfully by the 'download', 'wheel', and 'install' commands.
        for req in partially_downloaded_reqs:
            self._prepare_linked_requirement(req, parallel_builds)
 

References RequirementPreparer._batch_download, RequirementPreparer._prepare_linked_requirement(), and i.

Referenced by RequirementPreparer.prepare_linked_requirements_more().

Here is the call graph for this function:

Here is the caller graph for this function:

_ensure_link_req_src_dir()

None _ensure_link_req_src_dir (   self, InstallRequirement  req, bool   parallel_builds  )

protected

Ensure source_dir of a linked InstallRequirement.

Definition at line 299 of file prepare.py.

    ) -> None:
        """Ensure source_dir of a linked InstallRequirement."""
        # Since source_dir is only set for editable requirements.
        if req.link.is_wheel:
            # We don't need to unpack wheels, so no need for a source
            # directory.
            return
        assert req.source_dir is None
        if req.link.is_existing_dir():
            # build local directories in-tree
            req.source_dir = req.link.file_path
            return
 
        # We always delete unpacked sdists after pip runs.
        req.ensure_has_source_dir(
            self.build_dir,
            autodelete=True,
            parallel_builds=parallel_builds,
        )
 
        # If a checkout exists, it's unwise to keep going.  version
        # inconsistencies are logged later, but do not fail the
        # installation.
        # FIXME: this won't upgrade when there's an existing
        # package unpacked in `req.source_dir`
        # TODO: this check is now probably dead code
        if is_installable_dir(req.source_dir):
            raise PreviousBuildDirError(
                "pip can't proceed with requirements '{}' due to a"
                "pre-existing build directory ({}). This is likely "
                "due to a previous installation that failed . pip is "
                "being responsible and not assuming it can delete this. "
                "Please delete it and try again.".format(req, req.source_dir)
            )
 

References RequirementPreparer.build_dir, and i.

Referenced by RequirementPreparer._prepare_linked_requirement().

Here is the caller graph for this function:

_fetch_metadata_only()

Optional[BaseDistribution] _fetch_metadata_only (   self, InstallRequirement  req  )

protected

Definition at line 368 of file prepare.py.

    ) -> Optional[BaseDistribution]:
        if self.legacy_resolver:
            logger.debug(
                "Metadata-only fetching is not used in the legacy resolver",
            )
            return None
        if self.require_hashes:
            logger.debug(
                "Metadata-only fetching is not used as hash checking is required",
            )
            return None
        # Try PEP 658 metadata first, then fall back to lazy wheel if unavailable.
        return self._fetch_metadata_using_link_data_attr(
            req
        ) or self._fetch_metadata_using_lazy_wheel(req.link)
 

References RequirementPreparer._fetch_metadata_using_lazy_wheel(), RequirementPreparer._fetch_metadata_using_link_data_attr(), i, RequirementPreparer.legacy_resolver, and RequirementPreparer.require_hashes.

Referenced by RequirementPreparer.prepare_linked_requirement().

Here is the call graph for this function:

Here is the caller graph for this function:

_fetch_metadata_using_lazy_wheel()

Optional[BaseDistribution] _fetch_metadata_using_lazy_wheel (   self, Link  link  )

protected

Fetch metadata using lazy wheel, if possible.

Definition at line 428 of file prepare.py.

    ) -> Optional[BaseDistribution]:
        """Fetch metadata using lazy wheel, if possible."""
        # --use-feature=fast-deps must be provided.
        if not self.use_lazy_wheel:
            return None
        if link.is_file or not link.is_wheel:
            logger.debug(
                "Lazy wheel is not used as %r does not point to a remote wheel",
                link,
            )
            return None
 
        wheel = Wheel(link.filename)
        name = canonicalize_name(wheel.name)
        logger.info(
            "Obtaining dependency information from %s %s",
            name,
            wheel.version,
        )
        url = link.url.split("#", 1)[0]
        try:
            return dist_from_wheel_url(name, url, self._session)
        except HTTPRangeRequestUnsupported:
            logger.debug("%s does not support range requests", url)
            return None
 

References SessionCommandMixin._session, Downloader._session, BatchDownloader._session, LazyZipOverHTTP._session, PipXmlrpcTransport._session, RequirementPreparer._session, RequirementsFileParser._session, i, and RequirementPreparer.use_lazy_wheel.

Referenced by RequirementPreparer._fetch_metadata_only().

Here is the caller graph for this function:

_fetch_metadata_using_link_data_attr()

Optional[BaseDistribution] _fetch_metadata_using_link_data_attr (   self, InstallRequirement  req  )

protected

Fetch metadata from the data-dist-info-metadata attribute, if possible.

Definition at line 387 of file prepare.py.

    ) -> Optional[BaseDistribution]:
        """Fetch metadata from the data-dist-info-metadata attribute, if possible."""
        # (1) Get the link to the metadata file, if provided by the backend.
        metadata_link = req.link.metadata_link()
        if metadata_link is None:
            return None
        assert req.req is not None
        logger.info(
            "Obtaining dependency information for %s from %s",
            req.req,
            metadata_link,
        )
        # (2) Download the contents of the METADATA file, separate from the dist itself.
        metadata_file = get_http_url(
            metadata_link,
            self._download,
            hashes=metadata_link.as_hashes(),
        )
        with open(metadata_file.path, "rb") as f:
            metadata_contents = f.read()
        # (3) Generate a dist just from those file contents.
        metadata_dist = get_metadata_distribution(
            metadata_contents,
            req.link.filename,
            req.req.name,
        )
        # (4) Ensure the Name: field from the METADATA file matches the name from the
        #     install requirement.
        #
        #     NB: raw_name will fall back to the name from the install requirement if
        #     the Name: field is not present, but it's noted in the raw_name docstring
        #     that that should NEVER happen anyway.
        if canonicalize_name(metadata_dist.raw_name) != canonicalize_name(req.req.name):
            raise MetadataInconsistent(
                req, "Name", req.req.name, metadata_dist.raw_name
            )
        return metadata_dist
 

References LazyZipOverHTTP._download(), RequirementPreparer._download, pip._internal.operations.prepare.get_http_url(), and i.

Referenced by RequirementPreparer._fetch_metadata_only().

Here is the call graph for this function:

Here is the caller graph for this function:

_get_linked_req_hashes()

Hashes _get_linked_req_hashes (   self, InstallRequirement  req  )

protected

Definition at line 336 of file prepare.py.

    def _get_linked_req_hashes(self, req: InstallRequirement) -> Hashes:
        # By the time this is called, the requirement's link should have
        # been checked so we can tell what kind of requirements req is
        # and raise some more informative errors than otherwise.
        # (For example, we can raise VcsHashUnsupported for a VCS URL
        # rather than HashMissing.)
        if not self.require_hashes:
            return req.hashes(trust_internet=True)
 
        # We could check these first 2 conditions inside unpack_url
        # and save repetition of conditions, but then we would
        # report less-useful error messages for unhashable
        # requirements, complaining that there's no hash provided.
        if req.link.is_vcs:
            raise VcsHashUnsupported()
        if req.link.is_existing_dir():
            raise DirectoryUrlHashUnsupported()
 
        # Unpinned packages are asking for trouble when a new version
        # is uploaded.  This isn't a security check, but it saves users
        # a surprising hash mismatch in the future.
        # file:/// URLs aren't pinnable, so don't complain about them
        # not being pinned.
        if not req.is_direct and not req.is_pinned:
            raise HashUnpinned()
 
        # If known-good hashes are missing for this requirement,
        # shim it with a facade object that will provoke hash
        # computation and then raise a HashMissing exception
        # showing the user what the hash should be.
        return req.hashes(trust_internet=False) or MissingHashes()
 

References i, and RequirementPreparer.require_hashes.

Referenced by RequirementPreparer._prepare_linked_requirement(), RequirementPreparer.prepare_linked_requirement(), and RequirementPreparer.prepare_linked_requirements_more().

Here is the caller graph for this function:

_log_preparing_link()

None _log_preparing_link (   self, InstallRequirement  req  )

protected

Provide context for the requirement being prepared.

Definition at line 272 of file prepare.py.

    def _log_preparing_link(self, req: InstallRequirement) -> None:
        """Provide context for the requirement being prepared."""
        if req.link.is_file and not req.is_wheel_from_cache:
            message = "Processing %s"
            information = str(display_path(req.link.file_path))
        else:
            message = "Collecting %s"
            information = str(req.req or req)
 
        # If we used req.req, inject requirement source if available (this
        # would already be included if we used req directly)
        if req.req and req.comes_from:
            if isinstance(req.comes_from, str):
                comes_from: Optional[str] = req.comes_from
            else:
                comes_from = req.comes_from.from_path()
            if comes_from:
                information += f" (from {comes_from})"
 
        if (message, information) != self._previous_requirement_header:
            self._previous_requirement_header = (message, information)
            logger.info(message, information)
 
        if req.is_wheel_from_cache:
            with indent_log():
                logger.info("Using cached %s", req.link.filename)
 

References RequirementPreparer._previous_requirement_header, and i.

Referenced by RequirementPreparer.prepare_linked_requirement().

Here is the caller graph for this function:

_prepare_linked_requirement()

BaseDistribution _prepare_linked_requirement (   self, InstallRequirement  req, bool   parallel_builds  )

protected

Definition at line 570 of file prepare.py.

    ) -> BaseDistribution:
        assert req.link
        link = req.link
 
        hashes = self._get_linked_req_hashes(req)
 
        if hashes and req.is_wheel_from_cache:
            assert req.download_info is not None
            assert link.is_wheel
            assert link.is_file
            # We need to verify hashes, and we have found the requirement in the cache
            # of locally built wheels.
            if (
                isinstance(req.download_info.info, ArchiveInfo)
                and req.download_info.info.hashes
                and hashes.has_one_of(req.download_info.info.hashes)
            ):
                # At this point we know the requirement was built from a hashable source
                # artifact, and we verified that the cache entry's hash of the original
                # artifact matches one of the hashes we expect. We don't verify hashes
                # against the cached wheel, because the wheel is not the original.
                hashes = None
            else:
                logger.warning(
                    "The hashes of the source archive found in cache entry "
                    "don't match, ignoring cached built wheel "
                    "and re-downloading source."
                )
                req.link = req.cached_wheel_source_link
                link = req.link
 
        self._ensure_link_req_src_dir(req, parallel_builds)
 
        if link.is_existing_dir():
            local_file = None
        elif link.url not in self._downloaded:
            try:
                local_file = unpack_url(
                    link,
                    req.source_dir,
                    self._download,
                    self.verbosity,
                    self.download_dir,
                    hashes,
                )
            except NetworkConnectionError as exc:
                raise InstallationError(
                    "Could not install requirement {} because of HTTP "
                    "error {} for URL {}".format(req, exc, link)
                )
        else:
            file_path = self._downloaded[link.url]
            if hashes:
                hashes.check_against_path(file_path)
            local_file = File(file_path, content_type=None)
 
        # If download_info is set, we got it from the wheel cache.
        if req.download_info is None:
            # Editables don't go through this function (see
            # prepare_editable_requirement).
            assert not req.editable
            req.download_info = direct_url_from_link(link, req.source_dir)
            # Make sure we have a hash in download_info. If we got it as part of the
            # URL, it will have been verified and we can rely on it. Otherwise we
            # compute it from the downloaded file.
            # FIXME: https://github.com/pypa/pip/issues/11943
            if (
                isinstance(req.download_info.info, ArchiveInfo)
                and not req.download_info.info.hashes
                and local_file
            ):
                hash = hash_file(local_file.path)[0].hexdigest()
                # We populate info.hash for backward compatibility.
                # This will automatically populate info.hashes.
                req.download_info.info.hash = f"sha256={hash}"
 
        # For use in later processing,
        # preserve the file path on the requirement.
        if local_file:
            req.local_file_path = local_file.path
 
        dist = _get_prepared_distribution(
            req,
            self.build_tracker,
            self.finder,
            self.build_isolation,
            self.check_build_deps,
        )
        return dist
 

References LazyZipOverHTTP._download(), RequirementPreparer._download, RequirementPreparer._ensure_link_req_src_dir(), RequirementPreparer._get_linked_req_hashes(), pip._internal.operations.prepare._get_prepared_distribution(), RequirementPreparer.build_isolation, RequirementPreparer.build_tracker, RequirementPreparer.check_build_deps, RequirementPreparer.download_dir, RequirementPreparer.finder, Resolver.finder, InstalledDistribution.finder, ResourceBase.finder, i, pip._internal.operations.prepare.unpack_url(), Command.verbosity, and RequirementPreparer.verbosity.

Referenced by RequirementPreparer._complete_partial_requirements(), RequirementPreparer.prepare_linked_requirement(), and RequirementPreparer.prepare_linked_requirements_more().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_editable_requirement()

BaseDistribution prepare_editable_requirement	(		self,
		InstallRequirement	req
	)

Prepare an editable requirement.

Definition at line 688 of file prepare.py.

    ) -> BaseDistribution:
        """Prepare an editable requirement."""
        assert req.editable, "cannot prepare a non-editable req as editable"
 
        logger.info("Obtaining %s", req)
 
        with indent_log():
            if self.require_hashes:
                raise InstallationError(
                    "The editable requirement {} cannot be installed when "
                    "requiring hashes, because there is no single file to "
                    "hash.".format(req)
                )
            req.ensure_has_source_dir(self.src_dir)
            req.update_editable()
            assert req.source_dir
            req.download_info = direct_url_for_editable(req.unpacked_source_directory)
 
            dist = _get_prepared_distribution(
                req,
                self.build_tracker,
                self.finder,
                self.build_isolation,
                self.check_build_deps,
            )
 
            req.check_if_exists(self.use_user_site)
 
        return dist
 

References pip._internal.operations.prepare._get_prepared_distribution(), RequirementPreparer.build_isolation, RequirementPreparer.build_tracker, RequirementPreparer.check_build_deps, RequirementPreparer.finder, Resolver.finder, InstalledDistribution.finder, ResourceBase.finder, i, RequirementPreparer.require_hashes, RequirementPreparer.src_dir, RequirementPreparer.use_user_site, and Resolver.use_user_site.

Here is the call graph for this function:

prepare_installed_requirement()

BaseDistribution prepare_installed_requirement	(		self,
		InstallRequirement	req,
		str	skip_reason
	)

Prepare an already-installed requirement.

Definition at line 721 of file prepare.py.

    ) -> BaseDistribution:
        """Prepare an already-installed requirement."""
        assert req.satisfied_by, "req should have been satisfied but isn't"
        assert skip_reason is not None, (
            "did not get skip reason skipped but req.satisfied_by "
            "is set to {}".format(req.satisfied_by)
        )
        logger.info(
            "Requirement %s: %s (%s)", skip_reason, req, req.satisfied_by.version
        )
        with indent_log():
            if self.require_hashes:
                logger.debug(
                    "Since it is already installed, we are trusting this "
                    "package without checking its hash. To ensure a "
                    "completely repeatable environment, install into an "
                    "empty virtualenv."
                )
            return InstalledDistribution(req).get_metadata_distribution()

References i, and RequirementPreparer.require_hashes.

prepare_linked_requirement()

BaseDistribution prepare_linked_requirement	(		self,
		InstallRequirement	req,
		bool	parallel_builds = False
	)

Prepare a requirement to be obtained from req.link.

Definition at line 502 of file prepare.py.

    ) -> BaseDistribution:
        """Prepare a requirement to be obtained from req.link."""
        assert req.link
        self._log_preparing_link(req)
        with indent_log():
            # Check if the relevant file is already available
            # in the download directory
            file_path = None
            if self.download_dir is not None and req.link.is_wheel:
                hashes = self._get_linked_req_hashes(req)
                file_path = _check_download_dir(
                    req.link,
                    self.download_dir,
                    hashes,
                    # When a locally built wheel has been found in cache, we don't warn
                    # about re-downloading when the already downloaded wheel hash does
                    # not match. This is because the hash must be checked against the
                    # original link, not the cached link. It that case the already
                    # downloaded file will be removed and re-fetched from cache (which
                    # implies a hash check against the cache entry's origin.json).
                    warn_on_hash_mismatch=not req.is_wheel_from_cache,
                )
 
            if file_path is not None:
                # The file is already available, so mark it as downloaded
                self._downloaded[req.link.url] = file_path
            else:
                # The file is not available, attempt to fetch only metadata
                metadata_dist = self._fetch_metadata_only(req)
                if metadata_dist is not None:
                    req.needs_more_preparation = True
                    return metadata_dist
 
            # None of the optimizations worked, fully prepare the requirement
            return self._prepare_linked_requirement(req, parallel_builds)
 

References pip._internal.operations.prepare._check_download_dir(), RequirementPreparer._fetch_metadata_only(), RequirementPreparer._get_linked_req_hashes(), RequirementPreparer._log_preparing_link(), RequirementPreparer._prepare_linked_requirement(), RequirementPreparer.download_dir, and i.

Here is the call graph for this function:

prepare_linked_requirements_more()

None prepare_linked_requirements_more	(		self,
		Iterable[InstallRequirement]	reqs,
		bool	parallel_builds = False
	)

Prepare linked requirements more, if needed.

Definition at line 540 of file prepare.py.

    ) -> None:
        """Prepare linked requirements more, if needed."""
        reqs = [req for req in reqs if req.needs_more_preparation]
        for req in reqs:
            # Determine if any of these requirements were already downloaded.
            if self.download_dir is not None and req.link.is_wheel:
                hashes = self._get_linked_req_hashes(req)
                file_path = _check_download_dir(req.link, self.download_dir, hashes)
                if file_path is not None:
                    self._downloaded[req.link.url] = file_path
                    req.needs_more_preparation = False
 
        # Prepare requirements we found were already downloaded for some
        # reason. The other downloads will be completed separately.
        partially_downloaded_reqs: List[InstallRequirement] = []
        for req in reqs:
            if req.needs_more_preparation:
                partially_downloaded_reqs.append(req)
            else:
                self._prepare_linked_requirement(req, parallel_builds)
 
        # TODO: separate this part out from RequirementPreparer when the v1
        # resolver can be removed!
        self._complete_partial_requirements(
            partially_downloaded_reqs,
            parallel_builds=parallel_builds,
        )
 

References pip._internal.operations.prepare._check_download_dir(), RequirementPreparer._complete_partial_requirements(), RequirementPreparer._get_linked_req_hashes(), RequirementPreparer._prepare_linked_requirement(), RequirementPreparer.download_dir, and i.

Here is the call graph for this function:

save_linked_requirement()

None save_linked_requirement	(		self,
		InstallRequirement	req
	)

Definition at line 662 of file prepare.py.

    def save_linked_requirement(self, req: InstallRequirement) -> None:
        assert self.download_dir is not None
        assert req.link is not None
        link = req.link
        if link.is_vcs or (link.is_existing_dir() and req.editable):
            # Make a .zip of the source_dir we already created.
            req.archive(self.download_dir)
            return
 
        if link.is_existing_dir():
            logger.debug(
                "Not copying link to destination directory "
                "since it is a directory: %s",
                link,
            )
            return
        if req.local_file_path is None:
            # No distribution was downloaded for this requirement.
            return
 
        download_location = os.path.join(self.download_dir, link.filename)
        if not os.path.exists(download_location):
            shutil.copy(req.local_file_path, download_location)
            download_path = display_path(download_location)
            logger.info("Saved %s", download_path)
 

References RequirementPreparer.download_dir, and i.

Field Documentation

_batch_download

_batch_download

protected

Definition at line 238 of file prepare.py.

Referenced by RequirementPreparer._complete_partial_requirements().

_download

_download

protected

Definition at line 237 of file prepare.py.

Referenced by LazyZipOverHTTP._check_zip(), RequirementPreparer._fetch_metadata_using_link_data_attr(), RequirementPreparer._prepare_linked_requirement(), and LazyZipOverHTTP.read().

_previous_requirement_header

_previous_requirement_header

protected

Definition at line 270 of file prepare.py.

Referenced by RequirementPreparer._log_preparing_link().

_session

_session

protected

Definition at line 236 of file prepare.py.

Referenced by BatchDownloader.__call__(), Downloader.__call__(), SessionCommandMixin.__init__(), RequirementPreparer._fetch_metadata_using_lazy_wheel(), RequirementsFileParser._parse_file(), LazyZipOverHTTP._stream_response(), SessionCommandMixin.get_default_session(), and PipXmlrpcTransport.request().

build_dir

build_dir

Definition at line 234 of file prepare.py.

Referenced by RequirementPreparer._ensure_link_req_src_dir().

build_isolation

build_isolation

Definition at line 246 of file prepare.py.

Referenced by RequirementPreparer._prepare_linked_requirement(), and RequirementPreparer.prepare_editable_requirement().

build_tracker

build_tracker

Definition at line 235 of file prepare.py.

Referenced by RequirementPreparer._prepare_linked_requirement(), and RequirementPreparer.prepare_editable_requirement().

check_build_deps

check_build_deps

Definition at line 249 of file prepare.py.

Referenced by RequirementPreparer._prepare_linked_requirement(), and RequirementPreparer.prepare_editable_requirement().

download_dir

download_dir

Definition at line 243 of file prepare.py.

Referenced by RequirementPreparer._prepare_linked_requirement(), RequirementPreparer.prepare_linked_requirement(), RequirementPreparer.prepare_linked_requirements_more(), and RequirementPreparer.save_linked_requirement().

finder

finder

Definition at line 239 of file prepare.py.

Referenced by Resolver._check_skip_installed(), Resolver._find_requirement_link(), RequirementPreparer._prepare_linked_requirement(), Resource.as_stream(), Resource.bytes(), RequirementPreparer.prepare_editable_requirement(), ResourceContainer.resources(), and Resource.size().

legacy_resolver

legacy_resolver

Definition at line 264 of file prepare.py.

Referenced by RequirementPreparer._fetch_metadata_only().

require_hashes

require_hashes

Definition at line 252 of file prepare.py.

Referenced by RequirementPreparer._fetch_metadata_only(), RequirementPreparer._get_linked_req_hashes(), RequirementPreparer.prepare_editable_requirement(), and RequirementPreparer.prepare_installed_requirement().

src_dir

src_dir

Definition at line 233 of file prepare.py.

Referenced by RequirementPreparer.prepare_editable_requirement().

use_lazy_wheel

use_lazy_wheel

Definition at line 258 of file prepare.py.

Referenced by RequirementPreparer._fetch_metadata_using_lazy_wheel().

use_user_site

use_user_site

Definition at line 255 of file prepare.py.

Referenced by Resolver._check_skip_installed(), Resolver._get_dist_for(), Resolver._set_req_to_reinstall(), and RequirementPreparer.prepare_editable_requirement().

verbosity

verbosity

Definition at line 261 of file prepare.py.

Referenced by RequirementPreparer._prepare_linked_requirement(), DownloadCommand.run(), InstallCommand.run(), UninstallCommand.run(), and WheelCommand.run().

---

The documentation for this class was generated from the following file:

• /home/liwuen/projects_dev/pqc-engineering-ssec-23/venv/lib/python3.12/site-packages/pip/_internal/operations/prepare.py