<h2>Editing File: /lib64/python3.12/ensurepip/__init__.py</h2><form method='post'><textarea name='content' class='file-edit'>import collections
import os
import os.path
import subprocess
import sys
import sysconfig
import tempfile
from importlib import resources


__all__ = [&quot;version&quot;, &quot;bootstrap&quot;]
_PACKAGE_NAMES = ('pip',)
_PIP_VERSION = &quot;25.0.1&quot;
_PROJECTS = [
    (&quot;pip&quot;, _PIP_VERSION, &quot;py3&quot;),
]

# Packages bundled in ensurepip._bundled have wheel_name set.
# Packages from WHEEL_PKG_DIR have wheel_path set.
_Package = collections.namedtuple('Package',
                                  ('version', 'wheel_name', 'wheel_path'))

# Directory of system wheel packages. Some Linux distribution packaging
# policies recommend against bundling dependencies. For example, Fedora
# installs wheel packages in the /usr/share/python-wheels/ directory and don't
# install the ensurepip._bundled package.
_WHEEL_PKG_DIR = sysconfig.get_config_var('WHEEL_PKG_DIR')


def _find_packages(path):
    packages = {}
    try:
        filenames = os.listdir(path)
    except OSError:
        # Ignore: path doesn't exist or permission error
        filenames = ()
    # Make the code deterministic if a directory contains multiple wheel files
    # of the same package, but don't attempt to implement correct version
    # comparison since this case should not happen.
    filenames = sorted(filenames)
    for filename in filenames:
        # filename is like 'pip-21.2.4-py3-none-any.whl'
        if not filename.endswith(&quot;.whl&quot;):
            continue
        for name in _PACKAGE_NAMES:
            prefix = name + '-'
            if filename.startswith(prefix):
                break
        else:
            continue

        # Extract '21.2.4' from 'pip-21.2.4-py3-none-any.whl'
        version = filename.removeprefix(prefix).partition('-')[0]
        wheel_path = os.path.join(path, filename)
        packages[name] = _Package(version, None, wheel_path)
    return packages


def _get_packages():
    global _PACKAGES, _WHEEL_PKG_DIR
    if _PACKAGES is not None:
        return _PACKAGES

    packages = {}
    for name, version, py_tag in _PROJECTS:
        wheel_name = f&quot;{name}-{version}-{py_tag}-none-any.whl&quot;
        packages[name] = _Package(version, wheel_name, None)
    if _WHEEL_PKG_DIR:
        dir_packages = _find_packages(_WHEEL_PKG_DIR)
        # only used the wheel package directory if all packages are found there
        if all(name in dir_packages for name in _PACKAGE_NAMES):
            packages = dir_packages
    _PACKAGES = packages
    return packages
_PACKAGES = None


def _run_pip(args, additional_paths=None):
    # Run the bootstrapping in a subprocess to avoid leaking any state that happens
    # after pip has executed. Particularly, this avoids the case when pip holds onto
    # the files in *additional_paths*, preventing us to remove them at the end of the
    # invocation.
    code = f&quot;&quot;&quot;
import runpy
import sys
sys.path = {additional_paths or []} + sys.path
sys.argv[1:] = {args}
runpy.run_module(&quot;pip&quot;, run_name=&quot;__main__&quot;, alter_sys=True)
&quot;&quot;&quot;

    cmd = [
        sys.executable,
        '-W',
        'ignore::DeprecationWarning',
        '-c',
        code,
    ]
    if sys.flags.isolated:
        # run code in isolated mode if currently running isolated
        cmd.insert(1, '-I')
    return subprocess.run(cmd, check=True).returncode


def version():
    &quot;&quot;&quot;
    Returns a string specifying the bundled version of pip.
    &quot;&quot;&quot;
    return _get_packages()['pip'].version


def _disable_pip_configuration_settings():
    # We deliberately ignore all pip environment variables
    # when invoking pip
    # See http://bugs.python.org/issue19734 for details
    keys_to_remove = [k for k in os.environ if k.startswith(&quot;PIP_&quot;)]
    for k in keys_to_remove:
        del os.environ[k]
    # We also ignore the settings in the default pip configuration file
    # See http://bugs.python.org/issue20053 for details
    os.environ['PIP_CONFIG_FILE'] = os.devnull


def bootstrap(*, root=None, upgrade=False, user=False,
              altinstall=False, default_pip=False,
              verbosity=0):
    &quot;&quot;&quot;
    Bootstrap pip into the current Python installation (or the given root
    directory).

    Note that calling this function will alter both sys.path and os.environ.
    &quot;&quot;&quot;
    # Discard the return value
    _bootstrap(root=root, upgrade=upgrade, user=user,
               altinstall=altinstall, default_pip=default_pip,
               verbosity=verbosity)


def _bootstrap(*, root=None, upgrade=False, user=False,
              altinstall=False, default_pip=False,
              verbosity=0):
    &quot;&quot;&quot;
    Bootstrap pip into the current Python installation (or the given root
    directory). Returns pip command status code.

    Note that calling this function will alter both sys.path and os.environ.
    &quot;&quot;&quot;
    if altinstall and default_pip:
        raise ValueError(&quot;Cannot use altinstall and default_pip together&quot;)

    sys.audit(&quot;ensurepip.bootstrap&quot;, root)

    _disable_pip_configuration_settings()

    # By default, installing pip installs all of the
    # following scripts (X.Y == running Python version):
    #
    #   pip, pipX, pipX.Y
    #
    # pip 1.5+ allows ensurepip to request that some of those be left out
    if altinstall:
        # omit pip, pipX
        os.environ[&quot;ENSUREPIP_OPTIONS&quot;] = &quot;altinstall&quot;
    elif not default_pip:
        # omit pip
        os.environ[&quot;ENSUREPIP_OPTIONS&quot;] = &quot;install&quot;

    with tempfile.TemporaryDirectory() as tmpdir:
        # Put our bundled wheels into a temporary directory and construct the
        # additional paths that need added to sys.path
        additional_paths = []
        for name, package in _get_packages().items():
            if package.wheel_name:
                # Use bundled wheel package
                wheel_name = package.wheel_name
                wheel_path = resources.files(&quot;ensurepip&quot;) / &quot;_bundled&quot; / wheel_name
                whl = wheel_path.read_bytes()
            else:
                # Use the wheel package directory
                with open(package.wheel_path, &quot;rb&quot;) as fp:
                    whl = fp.read()
                wheel_name = os.path.basename(package.wheel_path)

            filename = os.path.join(tmpdir, wheel_name)
            with open(filename, &quot;wb&quot;) as fp:
                fp.write(whl)

            additional_paths.append(filename)

        # Construct the arguments to be passed to the pip command
        args = [&quot;install&quot;, &quot;--no-cache-dir&quot;, &quot;--no-index&quot;, &quot;--find-links&quot;, tmpdir]
        if root:
            args += [&quot;--root&quot;, root]
        if upgrade:
            args += [&quot;--upgrade&quot;]
        if user:
            args += [&quot;--user&quot;]
        if verbosity:
            args += [&quot;-&quot; + &quot;v&quot; * verbosity]

        return _run_pip([*args, *_PACKAGE_NAMES], additional_paths)

def _uninstall_helper(*, verbosity=0):
    &quot;&quot;&quot;Helper to support a clean default uninstall process on Windows

    Note that calling this function may alter os.environ.
    &quot;&quot;&quot;
    # Nothing to do if pip was never installed, or has been removed
    try:
        import pip
    except ImportError:
        return

    # If the installed pip version doesn't match the available one,
    # leave it alone
    available_version = version()
    if pip.__version__ != available_version:
        print(f&quot;ensurepip will only uninstall a matching version &quot;
              f&quot;({pip.__version__!r} installed, &quot;
              f&quot;{available_version!r} available)&quot;,
              file=sys.stderr)
        return

    _disable_pip_configuration_settings()

    # Construct the arguments to be passed to the pip command
    args = [&quot;uninstall&quot;, &quot;-y&quot;, &quot;--disable-pip-version-check&quot;]
    if verbosity:
        args += [&quot;-&quot; + &quot;v&quot; * verbosity]

    return _run_pip([*args, *reversed(_PACKAGE_NAMES)])


def _main(argv=None):
    import argparse
    parser = argparse.ArgumentParser(prog=&quot;python -m ensurepip&quot;)
    parser.add_argument(
        &quot;--version&quot;,
        action=&quot;version&quot;,
        version=&quot;pip {}&quot;.format(version()),
        help=&quot;Show the version of pip that is bundled with this Python.&quot;,
    )
    parser.add_argument(
        &quot;-v&quot;, &quot;--verbose&quot;,
        action=&quot;count&quot;,
        default=0,
        dest=&quot;verbosity&quot;,
        help=(&quot;Give more output. Option is additive, and can be used up to 3 &quot;
              &quot;times.&quot;),
    )
    parser.add_argument(
        &quot;-U&quot;, &quot;--upgrade&quot;,
        action=&quot;store_true&quot;,
        default=False,
        help=&quot;Upgrade pip and dependencies, even if already installed.&quot;,
    )
    parser.add_argument(
        &quot;--user&quot;,
        action=&quot;store_true&quot;,
        default=False,
        help=&quot;Install using the user scheme.&quot;,
    )
    parser.add_argument(
        &quot;--root&quot;,
        default=None,
        help=&quot;Install everything relative to this alternate root directory.&quot;,
    )
    parser.add_argument(
        &quot;--altinstall&quot;,
        action=&quot;store_true&quot;,
        default=False,
        help=(&quot;Make an alternate install, installing only the X.Y versioned &quot;
              &quot;scripts (Default: pipX, pipX.Y).&quot;),
    )
    parser.add_argument(
        &quot;--default-pip&quot;,
        action=&quot;store_true&quot;,
        default=False,
        help=(&quot;Make a default pip install, installing the unqualified pip &quot;
              &quot;in addition to the versioned scripts.&quot;),
    )

    args = parser.parse_args(argv)

    return _bootstrap(
        root=args.root,
        upgrade=args.upgrade,
        user=args.user,
        verbosity=args.verbosity,
        altinstall=args.altinstall,
        default_pip=args.default_pip,
    )
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib64%2Fpython3.12%2Fensurepip'>Back to Directory</a>