#$@%#$%!

Ngiler SH3LL 360
: / opt / hc_python / lib64 / python3.12 / site-packages / build /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	63.250.38.10
System	Linux premium90.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
User	likhxapw
PHP Version	8.3.30
Software	LiteSpeed
Doc root	Writable

Edit File : env.py \| Size : 13.91 KB
from __future__ import annotations import abc import functools import importlib.util import os import platform import shutil import subprocess import sys import sysconfig import tempfile import typing import warnings from collections.abc import Collection, Mapping from . import _ctx from ._ctx import run_subprocess from ._exceptions import FailedProcessError from ._util import check_dependency Installer = typing.Literal['pip', 'uv'] INSTALLERS = typing.get_args(Installer) class IsolatedEnv(typing.Protocol): """Isolated build environment ABC.""" @property @abc.abstractmethod def python_executable(self) -> str: """The Python executable of the isolated environment.""" @abc.abstractmethod def make_extra_environ(self) -> Mapping[str, str] \| None: """Generate additional env vars specific to the isolated environment.""" def _has_dependency(name: str, minimum_version_str: str \| None = None, /, distargs: object) -> bool \| None: """ Given a path, see if a package is present and return True if the version is sufficient for build, False if it is not, None if the package is missing. """ from packaging.version import Version from ._compat import importlib try: distribution = next(iter(importlib.metadata.distributions(name=name, distargs))) except StopIteration: return None if minimum_version_str is None: return True return Version(distribution.version) >= Version(minimum_version_str) class DefaultIsolatedEnv(IsolatedEnv): """ Isolated environment which supports several different underlying implementations. """ def __init__( self, , installer: Installer = 'pip', ) -> None: self.installer: Installer = installer def __enter__(self) -> DefaultIsolatedEnv: try: path = tempfile.mkdtemp(prefix='build-env-') # Call ``realpath`` to prevent spurious warning from being emitted # that the venv location has changed on Windows for the venv impl. # The username is DOS-encoded in the output of tempfile - the location is the same # but the representation of it is different, which confuses venv. # Ref: https://bugs.python.org/issue46171 path = os.path.realpath(path) self._path = path self._env_backend: _EnvBackend # uv is opt-in only. if self.installer == 'uv': self._env_backend = _UvBackend() else: self._env_backend = _PipBackend() _ctx.log(f'Creating isolated environment: {self._env_backend.display_name}...') self._env_backend.create(self._path) except Exception: # cleanup folder if creation fails self.__exit__(sys.exc_info()) raise return self def __exit__(self, args: object) -> None: if os.path.exists(self._path): # in case the user already deleted skip remove shutil.rmtree(self._path) @property def path(self) -> str: """The location of the isolated build environment.""" return self._path @property def python_executable(self) -> str: """The python executable of the isolated build environment.""" return self._env_backend.python_executable def make_extra_environ(self) -> dict[str, str]: path = os.environ.get('PATH') return { 'PATH': os.pathsep.join([self._env_backend.scripts_dir, path]) if path is not None else self._env_backend.scripts_dir } def install(self, requirements: Collection[str]) -> None: """ Install packages from PEP 508 requirements in the isolated build environment. :param requirements: PEP 508 requirement specification to install :note: Passing non-PEP 508 strings will result in undefined behavior, you should not* rely on it. It is merely an implementation detail, it may change any time without warning. """ if not requirements: return _ctx.log('Installing packages in isolated environment:\n' + '\n'.join(f'- {r}' for r in sorted(requirements))) self._env_backend.install_requirements(requirements) class _EnvBackend(typing.Protocol): # pragma: no cover python_executable: str scripts_dir: str def create(self, path: str) -> None: ... def install_requirements(self, requirements: Collection[str]) -> None: ... @property def display_name(self) -> str: ... class _PipBackend(_EnvBackend): def __init__(self) -> None: self._create_with_virtualenv = not self._has_valid_outer_pip and self._has_virtualenv @functools.cached_property def _has_valid_outer_pip(self) -> bool \| None: """ This checks for a valid global pip. Returns None if pip is missing, False if pip is too old, and True if it can be used. """ # Version to have added the `--python` option. if not _has_dependency('pip', '22.3'): # pragma: no cover return False # `pip install --python` is nonfunctional on Gentoo debundled pip. # Detect that by checking if pip._vendor` module exists. However, # searching for pip could yield warnings from _distutils_hack, # so silence them. with warnings.catch_warnings(): warnings.simplefilter('ignore') if importlib.util.find_spec('pip._vendor') is None: return False # pragma: no cover return True @functools.cached_property def _has_virtualenv(self) -> bool: """ virtualenv might be incompatible if it was installed separately from build. This verifies that virtualenv and all of its dependencies are installed as required by build. """ from packaging.requirements import Requirement name = 'virtualenv' return importlib.util.find_spec(name) is not None and not any( Requirement(d[1]).name == name for d in check_dependency(f'build[{name}]') if len(d) > 1 ) @staticmethod def _get_minimum_pip_version_str() -> str: if platform.system() == 'Darwin': release, _, machine = platform.mac_ver() if int(release[: release.find('.')]) >= 11: # macOS 11+ name scheme change requires 20.3. Intel macOS 11.0 can be # told to report 10.16 for backwards compatibility; but that also fixes # earlier versions of pip so this is only needed for 11+. is_apple_silicon_python = machine != 'x86_64' return '21.0.1' if is_apple_silicon_python else '20.3.0' # PEP-517 and manylinux1 was first implemented in 19.1 return '19.1.0' def create(self, path: str) -> None: if self._create_with_virtualenv: import packaging.version import virtualenv from ._compat import importlib virtualenv_ver = packaging.version.Version(importlib.metadata.version('virtualenv')) opts = [ path, '--activators', '', '--no-setuptools', '--no-periodic-update', ] if virtualenv_ver < packaging.version.Version('20.31.0'): opts.append('--no-wheel') result = virtualenv.cli_run(opts, setup_logging=False) # The creator attributes are `pathlib.Path`s. self.python_executable = str(result.creator.exe) self.scripts_dir = str(result.creator.script_dir) else: import venv with_pip = not self._has_valid_outer_pip try: venv.EnvBuilder(symlinks=_fs_supports_symlink(), with_pip=with_pip).create(path) except subprocess.CalledProcessError as exc: _ctx.log_subprocess_error(exc) raise FailedProcessError(exc, 'Failed to create venv. Maybe try installing virtualenv.') from None self.python_executable, self.scripts_dir, purelib = _find_executable_and_scripts(path) if with_pip: minimum_pip_version_str = self._get_minimum_pip_version_str() if not _has_dependency( 'pip', minimum_pip_version_str, path=[purelib], ): run_subprocess([self.python_executable, '-Im', 'pip', 'install', f'pip>={minimum_pip_version_str}']) # Uninstall setuptools from the build env to prevent depending on it implicitly. # Pythons 3.12 and up do not install setuptools, check if it exists first. if _has_dependency( 'setuptools', path=[purelib], ): run_subprocess([self.python_executable, '-Im', 'pip', 'uninstall', '-y', 'setuptools']) def install_requirements(self, requirements: Collection[str]) -> None: # pip does not honour environment markers in command line arguments # but it does from requirement files. with tempfile.NamedTemporaryFile('w', prefix='build-reqs-', suffix='.txt', delete=False, encoding='utf-8') as req_file: req_file.write(os.linesep.join(requirements)) try: if self._has_valid_outer_pip: cmd = [sys.executable, '-m', 'pip', '--python', self.python_executable] else: cmd = [self.python_executable, '-Im', 'pip'] if _ctx.verbosity > 1: cmd += [f'-{"v" * (_ctx.verbosity - 1)}'] cmd += [ 'install', '--use-pep517', '--no-warn-script-location', '--no-compile', '-r', os.path.abspath(req_file.name), ] run_subprocess(cmd) finally: os.unlink(req_file.name) @property def display_name(self) -> str: return 'virtualenv+pip' if self._create_with_virtualenv else 'venv+pip' class _UvBackend(_EnvBackend): def create(self, path: str) -> None: import venv self._env_path = path try: import uv self._uv_bin = uv.find_uv_bin() except (ModuleNotFoundError, FileNotFoundError): uv_bin = shutil.which('uv') if uv_bin is None: msg = 'uv executable not found' raise RuntimeError(msg) from None _ctx.log(f'Using external uv from {uv_bin}') self._uv_bin = uv_bin venv.EnvBuilder(symlinks=_fs_supports_symlink(), with_pip=False).create(self._env_path) self.python_executable, self.scripts_dir, _ = _find_executable_and_scripts(self._env_path) def install_requirements(self, requirements: Collection[str]) -> None: cmd = [self._uv_bin, 'pip'] if _ctx.verbosity > 1: cmd += [f'-{"v" * min(2, _ctx.verbosity - 1)}'] run_subprocess([cmd, 'install', requirements], env={**os.environ, 'VIRTUAL_ENV': self._env_path}) @property def display_name(self) -> str: return 'venv+uv' @functools.cache def _fs_supports_symlink() -> bool: """Return True if symlinks are supported""" # Using definition used by venv.main() if os.name != 'nt': return True # Windows may support symlinks (setting in Windows 10) with tempfile.NamedTemporaryFile(prefix='build-symlink-') as tmp_file: dest = f'{tmp_file}-b' try: os.symlink(tmp_file.name, dest) os.unlink(dest) except (OSError, NotImplementedError, AttributeError): return False return True def _find_executable_and_scripts(path: str) -> tuple[str, str, str]: """ Detect the Python executable and script folder of a virtual environment. :param path: The location of the virtual environment :return: The Python executable, script folder, and purelib folder """ config_vars = sysconfig.get_config_vars().copy() # globally cached, copy before altering it config_vars['base'] = path scheme_names = sysconfig.get_scheme_names() if 'venv' in scheme_names: # Python distributors with custom default installation scheme can set a # scheme that can't be used to expand the paths in a venv. # This can happen if build itself is not installed in a venv. # The distributors are encouraged to set a "venv" scheme to be used for this. # See https://bugs.python.org/issue45413 # and https://github.com/pypa/virtualenv/issues/2208 paths = sysconfig.get_paths(scheme='venv', vars=config_vars) elif 'posix_local' in scheme_names: # The Python that ships on Debian/Ubuntu varies the default scheme to # install to /usr/local # But it does not (yet) set the "venv" scheme. # If we're the Debian "posix_local" scheme is available, but "venv" # is not, we use "posix_prefix" instead which is venv-compatible there. paths = sysconfig.get_paths(scheme='posix_prefix', vars=config_vars) elif 'osx_framework_library' in scheme_names: # The Python that ships with the macOS developer tools varies the # default scheme depending on whether the ``sys.prefix`` is part of a framework. # But it does not (yet) set the "venv" scheme. # If the Apple-custom "osx_framework_library" scheme is available but "venv" # is not, we use "posix_prefix" instead which is venv-compatible there. paths = sysconfig.get_paths(scheme='posix_prefix', vars=config_vars) else: paths = sysconfig.get_paths(vars=config_vars) executable = os.path.join(paths['scripts'], 'python.exe' if os.name == 'nt' else 'python') if not os.path.exists(executable): msg = f'Virtual environment creation failed, executable {executable} missing' raise RuntimeError(msg) return executable, paths['scripts'], paths['purelib'] __all__ = [ 'DefaultIsolatedEnv', 'IsolatedEnv', ] Back

Edit File : env.py | Size : 13.91 KB

from __future__ import annotations

import abc
import functools
import importlib.util
import os
import platform
import shutil
import subprocess
import sys
import sysconfig
import tempfile
import typing
import warnings

from collections.abc import Collection, Mapping

from . import _ctx
from ._ctx import run_subprocess
from ._exceptions import FailedProcessError
from ._util import check_dependency

Installer = typing.Literal['pip', 'uv']

INSTALLERS = typing.get_args(Installer)

class IsolatedEnv(typing.Protocol):
    """Isolated build environment ABC."""

@property
    @abc.abstractmethod
    def python_executable(self) -> str:
        """The Python executable of the isolated environment."""

@abc.abstractmethod
    def make_extra_environ(self) -> Mapping[str, str] | None:
        """Generate additional env vars specific to the isolated environment."""

def _has_dependency(name: str, minimum_version_str: str | None = None, /, **distargs: object) -> bool | None:
    """
    Given a path, see if a package is present and return True if the version is
    sufficient for build, False if it is not, None if the package is missing.
    """
    from packaging.version import Version

from ._compat import importlib

try:
        distribution = next(iter(importlib.metadata.distributions(name=name, **distargs)))
    except StopIteration:
        return None

if minimum_version_str is None:
        return True

return Version(distribution.version) >= Version(minimum_version_str)

class DefaultIsolatedEnv(IsolatedEnv):
    """
    Isolated environment which supports several different underlying implementations.
    """

def __init__(
        self,
        *,
        installer: Installer = 'pip',
    ) -> None:
        self.installer: Installer = installer

def __enter__(self) -> DefaultIsolatedEnv:
        try:
            path = tempfile.mkdtemp(prefix='build-env-')
            # Call ``realpath`` to prevent spurious warning from being emitted
            # that the venv location has changed on Windows for the venv impl.
            # The username is DOS-encoded in the output of tempfile - the location is the same
            # but the representation of it is different, which confuses venv.
            # Ref: https://bugs.python.org/issue46171
            path = os.path.realpath(path)
            self._path = path

self._env_backend: _EnvBackend

# uv is opt-in only.
            if self.installer == 'uv':
                self._env_backend = _UvBackend()
            else:
                self._env_backend = _PipBackend()

_ctx.log(f'Creating isolated environment: {self._env_backend.display_name}...')
            self._env_backend.create(self._path)

except Exception:  # cleanup folder if creation fails
            self.__exit__(*sys.exc_info())
            raise

return self

def __exit__(self, *args: object) -> None:
        if os.path.exists(self._path):  # in case the user already deleted skip remove
            shutil.rmtree(self._path)

@property
    def path(self) -> str:
        """The location of the isolated build environment."""
        return self._path

@property
    def python_executable(self) -> str:
        """The python executable of the isolated build environment."""
        return self._env_backend.python_executable

def make_extra_environ(self) -> dict[str, str]:
        path = os.environ.get('PATH')
        return {
            'PATH': os.pathsep.join([self._env_backend.scripts_dir, path])
            if path is not None
            else self._env_backend.scripts_dir
        }

def install(self, requirements: Collection[str]) -> None:
        """
        Install packages from PEP 508 requirements in the isolated build environment.

:param requirements: PEP 508 requirement specification to install

:note: Passing non-PEP 508 strings will result in undefined behavior, you *should not* rely on it. It is
               merely an implementation detail, it may change any time without warning.
        """
        if not requirements:
            return

_ctx.log('Installing packages in isolated environment:\n' + '\n'.join(f'- {r}' for r in sorted(requirements)))
        self._env_backend.install_requirements(requirements)

class _EnvBackend(typing.Protocol):  # pragma: no cover
    python_executable: str
    scripts_dir: str

def create(self, path: str) -> None: ...

def install_requirements(self, requirements: Collection[str]) -> None: ...

@property
    def display_name(self) -> str: ...

class _PipBackend(_EnvBackend):
    def __init__(self) -> None:
        self._create_with_virtualenv = not self._has_valid_outer_pip and self._has_virtualenv

@functools.cached_property
    def _has_valid_outer_pip(self) -> bool | None:
        """
        This checks for a valid global pip. Returns None if pip is missing, False
        if pip is too old, and True if it can be used.
        """

# Version to have added the `--python` option.
        if not _has_dependency('pip', '22.3'):  # pragma: no cover
            return False

# `pip install --python` is nonfunctional on Gentoo debundled pip.
        # Detect that by checking if pip._vendor` module exists.  However,
        # searching for pip could yield warnings from _distutils_hack,
        # so silence them.
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')
            if importlib.util.find_spec('pip._vendor') is None:
                return False  # pragma: no cover

return True

@functools.cached_property
    def _has_virtualenv(self) -> bool:
        """
        virtualenv might be incompatible if it was installed separately
        from build. This verifies that virtualenv and all of its
        dependencies are installed as required by build.
        """
        from packaging.requirements import Requirement

name = 'virtualenv'

return importlib.util.find_spec(name) is not None and not any(
            Requirement(d[1]).name == name for d in check_dependency(f'build[{name}]') if len(d) > 1
        )

@staticmethod
    def _get_minimum_pip_version_str() -> str:
        if platform.system() == 'Darwin':
            release, _, machine = platform.mac_ver()
            if int(release[: release.find('.')]) >= 11:
                # macOS 11+ name scheme change requires 20.3. Intel macOS 11.0 can be
                # told to report 10.16 for backwards compatibility; but that also fixes
                # earlier versions of pip so this is only needed for 11+.
                is_apple_silicon_python = machine != 'x86_64'
                return '21.0.1' if is_apple_silicon_python else '20.3.0'

# PEP-517 and manylinux1 was first implemented in 19.1
        return '19.1.0'

def create(self, path: str) -> None:
        if self._create_with_virtualenv:
            import packaging.version
            import virtualenv

from ._compat import importlib

virtualenv_ver = packaging.version.Version(importlib.metadata.version('virtualenv'))

opts = [
                path,
                '--activators',
                '',
                '--no-setuptools',
                '--no-periodic-update',
            ]

if virtualenv_ver < packaging.version.Version('20.31.0'):
                opts.append('--no-wheel')

result = virtualenv.cli_run(opts, setup_logging=False)

# The creator attributes are `pathlib.Path`s.
            self.python_executable = str(result.creator.exe)
            self.scripts_dir = str(result.creator.script_dir)

else:
            import venv

with_pip = not self._has_valid_outer_pip

try:
                venv.EnvBuilder(symlinks=_fs_supports_symlink(), with_pip=with_pip).create(path)
            except subprocess.CalledProcessError as exc:
                _ctx.log_subprocess_error(exc)
                raise FailedProcessError(exc, 'Failed to create venv. Maybe try installing virtualenv.') from None

self.python_executable, self.scripts_dir, purelib = _find_executable_and_scripts(path)

if with_pip:
                minimum_pip_version_str = self._get_minimum_pip_version_str()
                if not _has_dependency(
                    'pip',
                    minimum_pip_version_str,
                    path=[purelib],
                ):
                    run_subprocess([self.python_executable, '-Im', 'pip', 'install', f'pip>={minimum_pip_version_str}'])

# Uninstall setuptools from the build env to prevent depending on it implicitly.
                # Pythons 3.12 and up do not install setuptools, check if it exists first.
                if _has_dependency(
                    'setuptools',
                    path=[purelib],
                ):
                    run_subprocess([self.python_executable, '-Im', 'pip', 'uninstall', '-y', 'setuptools'])

def install_requirements(self, requirements: Collection[str]) -> None:
        # pip does not honour environment markers in command line arguments
        # but it does from requirement files.
        with tempfile.NamedTemporaryFile('w', prefix='build-reqs-', suffix='.txt', delete=False, encoding='utf-8') as req_file:
            req_file.write(os.linesep.join(requirements))

try:
            if self._has_valid_outer_pip:
                cmd = [sys.executable, '-m', 'pip', '--python', self.python_executable]
            else:
                cmd = [self.python_executable, '-Im', 'pip']

if _ctx.verbosity > 1:
                cmd += [f'-{"v" * (_ctx.verbosity - 1)}']

cmd += [
                'install',
                '--use-pep517',
                '--no-warn-script-location',
                '--no-compile',
                '-r',
                os.path.abspath(req_file.name),
            ]
            run_subprocess(cmd)

finally:
            os.unlink(req_file.name)

@property
    def display_name(self) -> str:
        return 'virtualenv+pip' if self._create_with_virtualenv else 'venv+pip'

class _UvBackend(_EnvBackend):
    def create(self, path: str) -> None:
        import venv

self._env_path = path

try:
            import uv

self._uv_bin = uv.find_uv_bin()
        except (ModuleNotFoundError, FileNotFoundError):
            uv_bin = shutil.which('uv')
            if uv_bin is None:
                msg = 'uv executable not found'
                raise RuntimeError(msg) from None

_ctx.log(f'Using external uv from {uv_bin}')
            self._uv_bin = uv_bin

venv.EnvBuilder(symlinks=_fs_supports_symlink(), with_pip=False).create(self._env_path)
        self.python_executable, self.scripts_dir, _ = _find_executable_and_scripts(self._env_path)

def install_requirements(self, requirements: Collection[str]) -> None:
        cmd = [self._uv_bin, 'pip']
        if _ctx.verbosity > 1:
            cmd += [f'-{"v" * min(2, _ctx.verbosity - 1)}']
        run_subprocess([*cmd, 'install', *requirements], env={**os.environ, 'VIRTUAL_ENV': self._env_path})

@property
    def display_name(self) -> str:
        return 'venv+uv'

@functools.cache
def _fs_supports_symlink() -> bool:
    """Return True if symlinks are supported"""
    # Using definition used by venv.main()
    if os.name != 'nt':
        return True

# Windows may support symlinks (setting in Windows 10)
    with tempfile.NamedTemporaryFile(prefix='build-symlink-') as tmp_file:
        dest = f'{tmp_file}-b'
        try:
            os.symlink(tmp_file.name, dest)
            os.unlink(dest)
        except (OSError, NotImplementedError, AttributeError):
            return False
        return True

def _find_executable_and_scripts(path: str) -> tuple[str, str, str]:
    """
    Detect the Python executable and script folder of a virtual environment.

:param path: The location of the virtual environment
    :return: The Python executable, script folder, and purelib folder
    """
    config_vars = sysconfig.get_config_vars().copy()  # globally cached, copy before altering it
    config_vars['base'] = path
    scheme_names = sysconfig.get_scheme_names()
    if 'venv' in scheme_names:
        # Python distributors with custom default installation scheme can set a
        # scheme that can't be used to expand the paths in a venv.
        # This can happen if build itself is not installed in a venv.
        # The distributors are encouraged to set a "venv" scheme to be used for this.
        # See https://bugs.python.org/issue45413
        # and https://github.com/pypa/virtualenv/issues/2208
        paths = sysconfig.get_paths(scheme='venv', vars=config_vars)
    elif 'posix_local' in scheme_names:
        # The Python that ships on Debian/Ubuntu varies the default scheme to
        # install to /usr/local
        # But it does not (yet) set the "venv" scheme.
        # If we're the Debian "posix_local" scheme is available, but "venv"
        # is not, we use "posix_prefix" instead which is venv-compatible there.
        paths = sysconfig.get_paths(scheme='posix_prefix', vars=config_vars)
    elif 'osx_framework_library' in scheme_names:
        # The Python that ships with the macOS developer tools varies the
        # default scheme depending on whether the ``sys.prefix`` is part of a framework.
        # But it does not (yet) set the "venv" scheme.
        # If the Apple-custom "osx_framework_library" scheme is available but "venv"
        # is not, we use "posix_prefix" instead which is venv-compatible there.
        paths = sysconfig.get_paths(scheme='posix_prefix', vars=config_vars)
    else:
        paths = sysconfig.get_paths(vars=config_vars)

executable = os.path.join(paths['scripts'], 'python.exe' if os.name == 'nt' else 'python')
    if not os.path.exists(executable):
        msg = f'Virtual environment creation failed, executable {executable} missing'
        raise RuntimeError(msg)

return executable, paths['scripts'], paths['purelib']

__all__ = [
    'DefaultIsolatedEnv',
    'IsolatedEnv',
]

Back