Python build_env.BuildEnvironment方法代码示例

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def generate_metadata(build_env, backend):
    # type: (BuildEnvironment, Pep517HookCaller) -> str
    """Generate metadata using mechanisms described in PEP 517.

    Returns the generated metadata directory.
    """
    metadata_tmpdir = TempDirectory(
        kind="modern-metadata", globally_managed=True
    )

    metadata_dir = metadata_tmpdir.path

    with build_env:
        # Note that Pep517HookCaller implements a fallback for
        # prepare_metadata_for_build_wheel, so we don't have to
        # consider the possibility that this hook doesn't exist.
        runner = runner_with_spinner_message("Preparing wheel metadata")
        with backend.subprocess_runner(runner):
            distinfo_dir = backend.prepare_metadata_for_build_wheel(
                metadata_dir
            )

    return os.path.join(metadata_dir, distinfo_dir) 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def prep_for_dist(self, finder, build_isolation):
        # type: (PackageFinder, bool) -> None
        # Prepare for building. We need to:
        #   1. Load pyproject.toml (if it exists)
        #   2. Set up the build environment

        self.req.load_pyproject_toml()
        should_isolate = self.req.use_pep517 and build_isolation

        if should_isolate:
            # Isolate in a BuildEnvironment and install the build-time
            # requirements.
            self.req.build_env = BuildEnvironment()
            self.req.build_env.install_requirements(
                finder, self.req.pyproject_requires, 'overlay',
                "Installing build dependencies"
            )
            conflicting, missing = self.req.build_env.check_requirements(
                self.req.requirements_to_check
            )
            if conflicting:
                self._raise_conflicts("PEP 517/518 supported requirements",
                                      conflicting)
            if missing:
                logger.warning(
                    "Missing build requirements in pyproject.toml for %s.",
                    self.req,
                )
                logger.warning(
                    "The project does not specify a build backend, and "
                    "pip cannot fall back to setuptools without %s.",
                    " and ".join(map(repr, sorted(missing)))
                )

            # Install any extra build dependencies that the backend requests.
            # This must be done in a second pass, as the pyproject.toml
            # dependencies must be installed before we can call the backend.
            self.install_backend_dependencies(finder=finder)

        self.req.prepare_metadata()
        self.req.assert_source_matches_version() 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def prep_for_dist(self, finder, build_isolation):
        # Before calling "setup.py egg_info", we need to set-up the build
        # environment.
        build_requirements = self.req.get_pep_518_info()
        should_isolate = build_isolation and build_requirements is not None

        if should_isolate:
            # Haven't implemented PEP 517 yet, so spew a warning about it if
            # build-requirements don't include setuptools and wheel.
            missing_requirements = {'setuptools', 'wheel'} - {
                pkg_resources.Requirement(r).key for r in build_requirements
            }
            if missing_requirements:
                logger.warning(
                    "Missing build requirements in pyproject.toml for %s.",
                    self.req,
                )
                logger.warning(
                    "This version of pip does not implement PEP 517 so it "
                    "cannot build a wheel without %s.",
                    " and ".join(map(repr, sorted(missing_requirements)))
                )

            # Isolate in a BuildEnvironment and install the build-time
            # requirements.
            self.req.build_env = BuildEnvironment()
            self.req.build_env.install_requirements(
                finder, build_requirements,
                "Installing build dependencies"
            )

        self.req.run_egg_info()
        self.req.assert_source_matches_version() 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def prep_for_dist(self, finder, build_isolation):
        # Prepare for building. We need to:
        #   1. Load pyproject.toml (if it exists)
        #   2. Set up the build environment

        self.req.load_pyproject_toml()
        should_isolate = self.req.use_pep517 and build_isolation

        if should_isolate:
            # Isolate in a BuildEnvironment and install the build-time
            # requirements.
            self.req.build_env = BuildEnvironment()
            self.req.build_env.install_requirements(
                finder, self.req.pyproject_requires,
                "Installing build dependencies"
            )
            missing = []
            if self.req.requirements_to_check:
                check = self.req.requirements_to_check
                missing = self.req.build_env.missing_requirements(check)
            if missing:
                logger.warning(
                    "Missing build requirements in pyproject.toml for %s.",
                    self.req,
                )
                logger.warning(
                    "The project does not specify a build backend, and pip "
                    "cannot fall back to setuptools without %s.",
                    " and ".join(map(repr, sorted(missing)))
                )

        self.req.run_egg_info()
        self.req.assert_source_matches_version() 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def __init__(self, req, comes_from, source_dir=None, editable=False,
                 link=None, update=True, markers=None,
                 isolated=False, options=None, wheel_cache=None,
                 constraint=False, extras=()):
        assert req is None or isinstance(req, Requirement), req
        self.req = req
        self.comes_from = comes_from
        self.constraint = constraint
        if source_dir is not None:
            self.source_dir = os.path.normpath(os.path.abspath(source_dir))
        else:
            self.source_dir = None
        self.editable = editable

        self._wheel_cache = wheel_cache
        if link is not None:
            self.link = self.original_link = link
        else:
            from pip._internal.index import Link
            self.link = self.original_link = req and req.url and Link(req.url)

        if extras:
            self.extras = extras
        elif req:
            self.extras = {
                pkg_resources.safe_extra(extra) for extra in req.extras
            }
        else:
            self.extras = set()
        if markers is not None:
            self.markers = markers
        else:
            self.markers = req and req.marker
        self._egg_info_path = None
        # This holds the pkg_resources.Distribution object if this requirement
        # is already available:
        self.satisfied_by = None
        # This hold the pkg_resources.Distribution object if this requirement
        # conflicts with another installed distribution:
        self.conflicts_with = None
        # Temporary build location
        self._temp_build_dir = TempDirectory(kind="req-build")
        # Used to store the global directory where the _temp_build_dir should
        # have been created. Cf _correct_build_location method.
        self._ideal_build_dir = None
        # True if the editable should be updated:
        self.update = update
        # Set to True after successful installation
        self.install_succeeded = None
        # UninstallPathSet of uninstalled distribution (for possible rollback)
        self.uninstalled_pathset = None
        self.options = options if options else {}
        # Set to True after successful preparation of this requirement
        self.prepared = False
        self.is_direct = False

        self.isolated = isolated
        self.build_env = BuildEnvironment(no_clean=True) 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def prep_for_dist(self, finder, build_isolation):
        # type: (PackageFinder, bool) -> None
        # Prepare for building. We need to:
        #   1. Load pyproject.toml (if it exists)
        #   2. Set up the build environment

        self.req.load_pyproject_toml()
        should_isolate = self.req.use_pep517 and build_isolation

        def _raise_conflicts(conflicting_with, conflicting_reqs):
            raise InstallationError(
                "Some build dependencies for %s conflict with %s: %s." % (
                    self.req, conflicting_with, ', '.join(
                        '%s is incompatible with %s' % (installed, wanted)
                        for installed, wanted in sorted(conflicting))))

        if should_isolate:
            # Isolate in a BuildEnvironment and install the build-time
            # requirements.
            self.req.build_env = BuildEnvironment()
            self.req.build_env.install_requirements(
                finder, self.req.pyproject_requires, 'overlay',
                "Installing build dependencies"
            )
            conflicting, missing = self.req.build_env.check_requirements(
                self.req.requirements_to_check
            )
            if conflicting:
                _raise_conflicts("PEP 517/518 supported requirements",
                                 conflicting)
            if missing:
                logger.warning(
                    "Missing build requirements in pyproject.toml for %s.",
                    self.req,
                )
                logger.warning(
                    "The project does not specify a build backend, and "
                    "pip cannot fall back to setuptools without %s.",
                    " and ".join(map(repr, sorted(missing)))
                )
            # Install any extra build dependencies that the backend requests.
            # This must be done in a second pass, as the pyproject.toml
            # dependencies must be installed before we can call the backend.
            with self.req.build_env:
                # We need to have the env active when calling the hook.
                self.req.spin_message = "Getting requirements to build wheel"
                reqs = self.req.pep517_backend.get_requires_for_build_wheel()
            conflicting, missing = self.req.build_env.check_requirements(reqs)
            if conflicting:
                _raise_conflicts("the backend dependencies", conflicting)
            self.req.build_env.install_requirements(
                finder, missing, 'normal',
                "Installing backend dependencies"
            )

        self.req.prepare_metadata()
        self.req.assert_source_matches_version() 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def _setup_isolation(self, finder):
        def _raise_conflicts(conflicting_with, conflicting_reqs):
            format_string = (
                "Some build dependencies for {requirement} "
                "conflict with {conflicting_with}: {description}."
            )
            error_message = format_string.format(
                requirement=self.req,
                conflicting_with=conflicting_with,
                description=', '.join(
                    '%s is incompatible with %s' % (installed, wanted)
                    for installed, wanted in sorted(conflicting)
                )
            )
            raise InstallationError(error_message)

        # Isolate in a BuildEnvironment and install the build-time
        # requirements.
        self.req.build_env = BuildEnvironment()
        self.req.build_env.install_requirements(
            finder, self.req.pyproject_requires, 'overlay',
            "Installing build dependencies"
        )
        conflicting, missing = self.req.build_env.check_requirements(
            self.req.requirements_to_check
        )
        if conflicting:
            _raise_conflicts("PEP 517/518 supported requirements",
                             conflicting)
        if missing:
            logger.warning(
                "Missing build requirements in pyproject.toml for %s.",
                self.req,
            )
            logger.warning(
                "The project does not specify a build backend, and "
                "pip cannot fall back to setuptools without %s.",
                " and ".join(map(repr, sorted(missing)))
            )
        # Install any extra build dependencies that the backend requests.
        # This must be done in a second pass, as the pyproject.toml
        # dependencies must be installed before we can call the backend.
        with self.req.build_env:
            runner = runner_with_spinner_message(
                "Getting requirements to build wheel"
            )
            backend = self.req.pep517_backend
            with backend.subprocess_runner(runner):
                reqs = backend.get_requires_for_build_wheel()

        conflicting, missing = self.req.build_env.check_requirements(reqs)
        if conflicting:
            _raise_conflicts("the backend dependencies", conflicting)
        self.req.build_env.install_requirements(
            finder, missing, 'normal',
            "Installing backend dependencies"
        ) 

# 需要导入模块: from pip._internal import build_env [as 别名]
# 或者: from pip._internal.build_env import BuildEnvironment [as 别名]
def prepare_distribution_metadata(self, finder, build_isolation):
        # Prepare for building. We need to:
        #   1. Load pyproject.toml (if it exists)
        #   2. Set up the build environment

        self.req.load_pyproject_toml()
        should_isolate = self.req.use_pep517 and build_isolation

        def _raise_conflicts(conflicting_with, conflicting_reqs):
            raise InstallationError(
                "Some build dependencies for %s conflict with %s: %s." % (
                    self.req, conflicting_with, ', '.join(
                        '%s is incompatible with %s' % (installed, wanted)
                        for installed, wanted in sorted(conflicting))))

        if should_isolate:
            # Isolate in a BuildEnvironment and install the build-time
            # requirements.
            self.req.build_env = BuildEnvironment()
            self.req.build_env.install_requirements(
                finder, self.req.pyproject_requires, 'overlay',
                "Installing build dependencies"
            )
            conflicting, missing = self.req.build_env.check_requirements(
                self.req.requirements_to_check
            )
            if conflicting:
                _raise_conflicts("PEP 517/518 supported requirements",
                                 conflicting)
            if missing:
                logger.warning(
                    "Missing build requirements in pyproject.toml for %s.",
                    self.req,
                )
                logger.warning(
                    "The project does not specify a build backend, and "
                    "pip cannot fall back to setuptools without %s.",
                    " and ".join(map(repr, sorted(missing)))
                )
            # Install any extra build dependencies that the backend requests.
            # This must be done in a second pass, as the pyproject.toml
            # dependencies must be installed before we can call the backend.
            with self.req.build_env:
                # We need to have the env active when calling the hook.
                self.req.spin_message = "Getting requirements to build wheel"
                reqs = self.req.pep517_backend.get_requires_for_build_wheel()
            conflicting, missing = self.req.build_env.check_requirements(reqs)
            if conflicting:
                _raise_conflicts("the backend dependencies", conflicting)
            self.req.build_env.install_requirements(
                finder, missing, 'normal',
                "Installing backend dependencies"
            )

        self.req.prepare_metadata()
        self.req.assert_source_matches_version()