Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! __init__.pynu [ PK ! ľ
*& *& freeze.pynu [ import collections
import logging
import os
from typing import Container, Dict, Iterable, Iterator, List, NamedTuple, Optional, Set
from pip._vendor.packaging.utils import canonicalize_name
from pip._vendor.packaging.version import Version
from pip._internal.exceptions import BadCommand, InstallationError
from pip._internal.metadata import BaseDistribution, get_environment
from pip._internal.req.constructors import (
install_req_from_editable,
install_req_from_line,
)
from pip._internal.req.req_file import COMMENT_RE
from pip._internal.utils.direct_url_helpers import direct_url_as_pep440_direct_reference
logger = logging.getLogger(__name__)
class _EditableInfo(NamedTuple):
requirement: str
comments: List[str]
def freeze(
requirement: Optional[List[str]] = None,
local_only: bool = False,
user_only: bool = False,
paths: Optional[List[str]] = None,
isolated: bool = False,
exclude_editable: bool = False,
skip: Container[str] = (),
) -> Iterator[str]:
installations: Dict[str, FrozenRequirement] = {}
dists = get_environment(paths).iter_installed_distributions(
local_only=local_only,
skip=(),
user_only=user_only,
)
for dist in dists:
req = FrozenRequirement.from_dist(dist)
if exclude_editable and req.editable:
continue
installations[req.canonical_name] = req
if requirement:
# the options that don't get turned into an InstallRequirement
# should only be emitted once, even if the same option is in multiple
# requirements files, so we need to keep track of what has been emitted
# so that we don't emit it again if it's seen again
emitted_options: Set[str] = set()
# keep track of which files a requirement is in so that we can
# give an accurate warning if a requirement appears multiple times.
req_files: Dict[str, List[str]] = collections.defaultdict(list)
for req_file_path in requirement:
with open(req_file_path) as req_file:
for line in req_file:
if (
not line.strip()
or line.strip().startswith("#")
or line.startswith(
(
"-r",
"--requirement",
"-f",
"--find-links",
"-i",
"--index-url",
"--pre",
"--trusted-host",
"--process-dependency-links",
"--extra-index-url",
"--use-feature",
)
)
):
line = line.rstrip()
if line not in emitted_options:
emitted_options.add(line)
yield line
continue
if line.startswith("-e") or line.startswith("--editable"):
if line.startswith("-e"):
line = line[2:].strip()
else:
line = line[len("--editable") :].strip().lstrip("=")
line_req = install_req_from_editable(
line,
isolated=isolated,
)
else:
line_req = install_req_from_line(
COMMENT_RE.sub("", line).strip(),
isolated=isolated,
)
if not line_req.name:
logger.info(
"Skipping line in requirement file [%s] because "
"it's not clear what it would install: %s",
req_file_path,
line.strip(),
)
logger.info(
" (add #egg=PackageName to the URL to avoid"
" this warning)"
)
else:
line_req_canonical_name = canonicalize_name(line_req.name)
if line_req_canonical_name not in installations:
# either it's not installed, or it is installed
# but has been processed already
if not req_files[line_req.name]:
logger.warning(
"Requirement file [%s] contains %s, but "
"package %r is not installed",
req_file_path,
COMMENT_RE.sub("", line).strip(),
line_req.name,
)
else:
req_files[line_req.name].append(req_file_path)
else:
yield str(installations[line_req_canonical_name]).rstrip()
del installations[line_req_canonical_name]
req_files[line_req.name].append(req_file_path)
# Warn about requirements that were included multiple times (in a
# single requirements file or in different requirements files).
for name, files in req_files.items():
if len(files) > 1:
logger.warning(
"Requirement %s included multiple times [%s]",
name,
", ".join(sorted(set(files))),
)
yield ("## The following requirements were added by pip freeze:")
for installation in sorted(installations.values(), key=lambda x: x.name.lower()):
if installation.canonical_name not in skip:
yield str(installation).rstrip()
def _format_as_name_version(dist: BaseDistribution) -> str:
if isinstance(dist.version, Version):
return f"{dist.raw_name}=={dist.version}"
return f"{dist.raw_name}==={dist.version}"
def _get_editable_info(dist: BaseDistribution) -> _EditableInfo:
"""
Compute and return values (req, comments) for use in
FrozenRequirement.from_dist().
"""
editable_project_location = dist.editable_project_location
assert editable_project_location
location = os.path.normcase(os.path.abspath(editable_project_location))
from pip._internal.vcs import RemoteNotFoundError, RemoteNotValidError, vcs
vcs_backend = vcs.get_backend_for_dir(location)
if vcs_backend is None:
display = _format_as_name_version(dist)
logger.debug(
'No VCS found for editable requirement "%s" in: %r',
display,
location,
)
return _EditableInfo(
requirement=location,
comments=[f"# Editable install with no version control ({display})"],
)
vcs_name = type(vcs_backend).__name__
try:
req = vcs_backend.get_src_requirement(location, dist.raw_name)
except RemoteNotFoundError:
display = _format_as_name_version(dist)
return _EditableInfo(
requirement=location,
comments=[f"# Editable {vcs_name} install with no remote ({display})"],
)
except RemoteNotValidError as ex:
display = _format_as_name_version(dist)
return _EditableInfo(
requirement=location,
comments=[
f"# Editable {vcs_name} install ({display}) with either a deleted "
f"local remote or invalid URI:",
f"# '{ex.url}'",
],
)
except BadCommand:
logger.warning(
"cannot determine version of editable source in %s "
"(%s command not found in path)",
location,
vcs_backend.name,
)
return _EditableInfo(requirement=location, comments=[])
except InstallationError as exc:
logger.warning("Error when trying to get requirement for VCS system %s", exc)
else:
return _EditableInfo(requirement=req, comments=[])
logger.warning("Could not determine repository location of %s", location)
return _EditableInfo(
requirement=location,
comments=["## !! Could not determine repository location"],
)
class FrozenRequirement:
def __init__(
self,
name: str,
req: str,
editable: bool,
comments: Iterable[str] = (),
) -> None:
self.name = name
self.canonical_name = canonicalize_name(name)
self.req = req
self.editable = editable
self.comments = comments
@classmethod
def from_dist(cls, dist: BaseDistribution) -> "FrozenRequirement":
editable = dist.editable
if editable:
req, comments = _get_editable_info(dist)
else:
comments = []
direct_url = dist.direct_url
if direct_url:
# if PEP 610 metadata is present, use it
req = direct_url_as_pep440_direct_reference(direct_url, dist.raw_name)
else:
# name==version requirement
req = _format_as_name_version(dist)
return cls(dist.raw_name, req, editable, comments=comments)
def __str__(self) -> str:
req = self.req
if self.editable:
req = f"-e {req}"
return "\n".join(list(self.comments) + [str(req)]) + "\n"
PK ! kv __init__.pyonu [
abc @ s d S( N( ( ( ( s; /usr/lib/python2.7/site-packages/pip/operations/__init__.pyt t PK ! Ԟ+8s s
freeze.pyonu [
abc
@@ s d d l m Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d d l m
Z
d d l m Z d d l
m Z d d l m Z e j e Z d d d d d d e d d
d Z d S( i ( t absolute_importN( t InstallRequirement( t
COMMENT_RE( t get_installed_distributions( t
pkg_resources( t canonicalize_name( t RequirementParseErrorc c@ s | p g } d } | r- t j | j } n g }
x9 t j D]. } | j d r= |
j | j d q= q= Wx* | D]" } d | k rv |
j | qv qv Wx | D] } d | Vq Wi }
xs t
d | d d# d | D]V } y t j j
| |
} Wn' t k
r t j d | j q n X| |
| j R ( ( s -rs
--requirements -Zs --always-unzips -fs --find-linkss -is --index-urls --pres --trusted-hosts --process-dependency-linkss --extra-index-url(% t Nonet ret compilet searchR t working_sett has_metadatat extendt get_metadata_linest appendR t pipt FrozenRequirementt from_distR t loggert warningt project_nameR t sett opent stript
startswitht rstript addt lent lstripR t
from_editablet from_lineR t subt infot strt sortedt valuesR ( t requirementt
find_linksR R t
skip_regexR R
R R t
skip_matcht dependency_linkst distt linkt
installationst reqt emitted_optionst
req_file_patht req_filet linet line_reqt installation( ( s9 /usr/lib/python2.7/site-packages/pip/operations/freeze.pyt freeze s
( ( t
__future__R t loggingR R t pip.reqR t pip.req.req_fileR t pip.utilsR t pip._vendorR t pip._vendor.packaging.utilsR t pip._vendor.pkg_resourcesR t getLoggert __name__R! R t FalseRB ( ( ( s9 /usr/lib/python2.7/site-packages/pip/operations/freeze.pyt s PK ! % check.pycnu [
abc @ s d Z d Z d Z d S( c C s i } i } xt | D]l } d | j | j f } t t | | } | rW | | | | j D]0 } | j j | k r, | j | | Vq, q, Wd S( s\ Return all of the requirements of `dist` that aren't present in
`installed_dists`.
c s s | ] } | j j Vq d S( N( R t lower( t .0t d( ( s8 /usr/lib/python2.7/site-packages/pip/operations/check.pys s N( t sett requiresR R
t add( R R t installed_namest missing_requirementst requirement( ( s8 /usr/lib/python2.7/site-packages/pip/operations/check.pyR s
c c sq i } x | D] } | | | j s PK ! % check.pyonu [
abc @ s d Z d Z d Z d S( c C s i } i } xt | D]l } d | j | j f } t t | | } | rW | | | | j D]0 } | j j | k r, | j | | Vq, q, Wd S( s\ Return all of the requirements of `dist` that aren't present in
`installed_dists`.
c s s | ] } | j j Vq d S( N( R t lower( t .0t d( ( s8 /usr/lib/python2.7/site-packages/pip/operations/check.pys s N( t sett requiresR R
t add( R R t installed_namest missing_requirementst requirement( ( s8 /usr/lib/python2.7/site-packages/pip/operations/check.pyR s
c c sq i } x | D] } | | | j s PK ! ͯ check.pynu [ """Validation of dependencies of packages
"""
import logging
from typing import Callable, Dict, List, NamedTuple, Optional, Set, Tuple
from pip._vendor.packaging.requirements import Requirement
from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
from pip._internal.distributions import make_distribution_for_install_requirement
from pip._internal.metadata import get_default_environment
from pip._internal.metadata.base import DistributionVersion
from pip._internal.req.req_install import InstallRequirement
logger = logging.getLogger(__name__)
class PackageDetails(NamedTuple):
version: DistributionVersion
dependencies: List[Requirement]
# Shorthands
PackageSet = Dict[NormalizedName, PackageDetails]
Missing = Tuple[NormalizedName, Requirement]
Conflicting = Tuple[NormalizedName, DistributionVersion, Requirement]
MissingDict = Dict[NormalizedName, List[Missing]]
ConflictingDict = Dict[NormalizedName, List[Conflicting]]
CheckResult = Tuple[MissingDict, ConflictingDict]
ConflictDetails = Tuple[PackageSet, CheckResult]
def create_package_set_from_installed() -> Tuple[PackageSet, bool]:
"""Converts a list of distributions into a PackageSet."""
package_set = {}
problems = False
env = get_default_environment()
for dist in env.iter_installed_distributions(local_only=False, skip=()):
name = dist.canonical_name
try:
dependencies = list(dist.iter_dependencies())
package_set[name] = PackageDetails(dist.version, dependencies)
except (OSError, ValueError) as e:
# Don't crash on unreadable or broken metadata.
logger.warning("Error parsing requirements for %s: %s", name, e)
problems = True
return package_set, problems
def check_package_set(
package_set: PackageSet, should_ignore: Optional[Callable[[str], bool]] = None
) -> CheckResult:
"""Check if a package set is consistent
If should_ignore is passed, it should be a callable that takes a
package name and returns a boolean.
"""
missing = {}
conflicting = {}
for package_name, package_detail in package_set.items():
# Info about dependencies of package_name
missing_deps: Set[Missing] = set()
conflicting_deps: Set[Conflicting] = set()
if should_ignore and should_ignore(package_name):
continue
for req in package_detail.dependencies:
name = canonicalize_name(req.name)
# Check if it's missing
if name not in package_set:
missed = True
if req.marker is not None:
missed = req.marker.evaluate()
if missed:
missing_deps.add((name, req))
continue
# Check if there's a conflict
version = package_set[name].version
if not req.specifier.contains(version, prereleases=True):
conflicting_deps.add((name, version, req))
if missing_deps:
missing[package_name] = sorted(missing_deps, key=str)
if conflicting_deps:
conflicting[package_name] = sorted(conflicting_deps, key=str)
return missing, conflicting
def check_install_conflicts(to_install: List[InstallRequirement]) -> ConflictDetails:
"""For checking if the dependency graph would be consistent after \
installing given requirements
"""
# Start from the current state
package_set, _ = create_package_set_from_installed()
# Install packages
would_be_installed = _simulate_installation_of(to_install, package_set)
# Only warn about directly-dependent packages; create a whitelist of them
whitelist = _create_whitelist(would_be_installed, package_set)
return (
package_set,
check_package_set(
package_set, should_ignore=lambda name: name not in whitelist
),
)
def _simulate_installation_of(
to_install: List[InstallRequirement], package_set: PackageSet
) -> Set[NormalizedName]:
"""Computes the version of packages after installing to_install."""
# Keep track of packages that were installed
installed = set()
# Modify it as installing requirement_set would (assuming no errors)
for inst_req in to_install:
abstract_dist = make_distribution_for_install_requirement(inst_req)
dist = abstract_dist.get_metadata_distribution()
name = dist.canonical_name
package_set[name] = PackageDetails(dist.version, list(dist.iter_dependencies()))
installed.add(name)
return installed
def _create_whitelist(
would_be_installed: Set[NormalizedName], package_set: PackageSet
) -> Set[NormalizedName]:
packages_affected = set(would_be_installed)
for package_name in package_set:
if package_name in packages_affected:
continue
for req in package_set[package_name].dependencies:
if canonicalize_name(req.name) in packages_affected:
packages_affected.add(package_name)
break
return packages_affected
PK ! Ԟ+8s s
freeze.pycnu [
abc
@@ s d d l m Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d d l m
Z
d d l m Z d d l
m Z d d l m Z e j e Z d d d d d d e d d
d Z d S( i ( t absolute_importN( t InstallRequirement( t
COMMENT_RE( t get_installed_distributions( t
pkg_resources( t canonicalize_name( t RequirementParseErrorc c@ s | p g } d } | r- t j | j } n g }
x9 t j D]. } | j d r= |
j | j d q= q= Wx* | D]" } d | k rv |
j | qv qv Wx | D] } d | Vq Wi }
xs t
d | d d# d | D]V } y t j j
| |
} Wn' t k
r t j d | j q n X| |
| j R ( ( s -rs
--requirements -Zs --always-unzips -fs --find-linkss -is --index-urls --pres --trusted-hosts --process-dependency-linkss --extra-index-url(% t Nonet ret compilet searchR t working_sett has_metadatat extendt get_metadata_linest appendR t pipt FrozenRequirementt from_distR t loggert warningt project_nameR t sett opent stript
startswitht rstript addt lent lstripR t
from_editablet from_lineR t subt infot strt sortedt valuesR ( t requirementt
find_linksR R t
skip_regexR R
R R t
skip_matcht dependency_linkst distt linkt
installationst reqt emitted_optionst
req_file_patht req_filet linet line_reqt installation( ( s9 /usr/lib/python2.7/site-packages/pip/operations/freeze.pyt freeze s
( ( t
__future__R t loggingR R t pip.reqR t pip.req.req_fileR t pip.utilsR t pip._vendorR t pip._vendor.packaging.utilsR t pip._vendor.pkg_resourcesR t getLoggert __name__R! R t FalseRB ( ( ( s9 /usr/lib/python2.7/site-packages/pip/operations/freeze.pyt s PK ! kv __init__.pycnu [
abc @ s d S( N( ( ( ( s; /usr/lib/python2.7/site-packages/pip/operations/__init__.pyt t PK ! )x x __pycache__/check.cpython-36.pycnu [ 3
Pf6 @ s d d Z dd Zdd ZdS )c C sb i }i }xP| D ]H}d|j |jf }tt|| }|r<|||< tt|| }|r|||< qW ||fS )Nz%s==%s) project_nameversionlistget_missing_reqsget_incompatible_reqs)installed_distsZmissing_reqs_dictZincompatible_reqs_dictdistkeyZ missing_reqsZincompatible_reqs r /usr/lib/python3.6/check.pycheck_requirements s
r c c sL t dd |D }t }x.| j D ]"}|jj |kr"|j| |V q"W dS )z\Return all of the requirements of `dist` that aren't present in
`installed_dists`.
c s s | ]}|j j V qd S )N)r lower).0dr r r
s z#get_missing_reqs..N)setrequiresr r add)r r Zinstalled_namesZmissing_requirements requirementr r r
r s
r c c sT i }x|D ]}|||j < q
W x2| j D ]&}|j|j }|r&||kr&||fV q&W dS )zyReturn all of the requirements of `dist` that are present in
`installed_dists`, but have incompatible versions.
N)r r get)r r Zinstalled_dists_by_nameZinstalled_distr Z present_distr r r
r $ s
r N)r r r r r r r
s PK ! PH) ) ! __pycache__/freeze.cpython-36.pycnu [ 3
PfJ @ s d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m Z d dl
mZ d dlmZ ejeZddddddd df f d
d ZdS ) )absolute_importN)InstallRequirement)
COMMENT_RE)get_installed_distributions)
pkg_resources)canonicalize_name)RequirementParseErrorFc c s |pg }d } |r t j|j} g }
x(tjD ] } | jdr(|
j| jd q(W x |D ]} d| krP|
j| qPW x|D ]} d| V qpW i }
xXt |f |dD ]F} yt
j j | |
}W n$ t
k
r tjd| j wY nX ||
|j< qW | rvt }x| D ]v}t|b}xX|D ]N}|j sL|j jdsL| r@| |sL|jd!rr|j }||kr|j| |V q|jds|jdr|jdr|dd j }n|tdd j jd}tj||||d}n tj t j d|j ||d}|jstj d||j tj d nD|j|
kr@tjd |t j d|j n t |
|j j V |
|j= qW W d Q R X qW d V x s zfreeze..)key) r
r r r r r r r r r r r )$recompilesearchr Z working_setZ has_metadataextendZget_metadata_linesappendr pipZFrozenRequirementZ from_distr loggerZwarningZ project_namer setopenstrip
startswithrstripaddlenlstripr Z
from_editableZ from_liner subinfostrsortedvaluesr )Z requirementZ
find_linksr r Z
skip_regexr r r r
Z
skip_matchZdependency_linksZdistlinkZ
installationsZreqZemitted_optionsZ
req_file_pathZreq_filelineZline_reqZ installationr" r" r# freeze s
r< )Z
__future__r Zloggingr& r+ Zpip.reqr Zpip.req.req_filer Z pip.utilsr Z pip._vendorr Zpip._vendor.packaging.utilsr Zpip._vendor.pkg_resourcesr Z getLogger__name__r, r< r" r" r" r# s
PK ! )x x & __pycache__/check.cpython-36.opt-1.pycnu [ 3
Pf6 @ s d d Z dd Zdd ZdS )c C sb i }i }xP| D ]H}d|j |jf }tt|| }|r<|||< tt|| }|r|||< qW ||fS )Nz%s==%s) project_nameversionlistget_missing_reqsget_incompatible_reqs)installed_distsZmissing_reqs_dictZincompatible_reqs_dictdistkeyZ missing_reqsZincompatible_reqs r /usr/lib/python3.6/check.pycheck_requirements s
r c c sL t dd |D }t }x.| j D ]"}|jj |kr"|j| |V q"W dS )z\Return all of the requirements of `dist` that aren't present in
`installed_dists`.
c s s | ]}|j j V qd S )N)r lower).0dr r r
s z#get_missing_reqs..N)setrequiresr r add)r r Zinstalled_namesZmissing_requirements requirementr r r
r s
r c c sT i }x|D ]}|||j < q
W x2| j D ]&}|j|j }|r&||kr&||fV q&W dS )zyReturn all of the requirements of `dist` that are present in
`installed_dists`, but have incompatible versions.
N)r r get)r r Zinstalled_dists_by_nameZinstalled_distr Z present_distr r r
r $ s
r N)r r r r r r r
s PK ! m-Wq q # __pycache__/__init__.cpython-36.pycnu [ 3
Pf @ s d S )N r r r /usr/lib/python3.6/__init__.py s PK ! m-Wq q ) __pycache__/__init__.cpython-36.opt-1.pycnu [ 3
Pf @ s d S )N r r r /usr/lib/python3.6/__init__.py s PK ! PH) ) ' __pycache__/freeze.cpython-36.opt-1.pycnu [ 3
PfJ @ s d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m Z d dl
mZ d dlmZ ejeZddddddd df f d
d ZdS ) )absolute_importN)InstallRequirement)
COMMENT_RE)get_installed_distributions)
pkg_resources)canonicalize_name)RequirementParseErrorFc c s |pg }d } |r t j|j} g }
x(tjD ] } | jdr(|
j| jd q(W x |D ]} d| krP|
j| qPW x|D ]} d| V qpW i }
xXt |f |dD ]F} yt
j j | |
}W n$ t
k
r tjd| j wY nX ||
|j< qW | rvt }x| D ]v}t|b}xX|D ]N}|j sL|j jdsL| r@| |sL|jd!rr|j }||kr|j| |V q|jds|jdr|jdr|dd j }n|tdd j jd}tj||||d}n tj t j d|j ||d}|jstj d||j tj d nD|j|
kr@tjd |t j d|j n t |
|j j V |
|j= qW W d Q R X qW d V x s zfreeze..)key) r
r r r r r r r r r r r )$recompilesearchr Z working_setZ has_metadataextendZget_metadata_linesappendr pipZFrozenRequirementZ from_distr loggerZwarningZ project_namer setopenstrip
startswithrstripaddlenlstripr Z
from_editableZ from_liner subinfostrsortedvaluesr )Z requirementZ
find_linksr r Z
skip_regexr r r r
Z
skip_matchZdependency_linksZdistlinkZ
installationsZreqZemitted_optionsZ
req_file_pathZreq_filelineZline_reqZ installationr" r" r# freeze s
r< )Z
__future__r Zloggingr& r+ Zpip.reqr Zpip.req.req_filer Z pip.utilsr Z pip._vendorr Zpip._vendor.packaging.utilsr Zpip._vendor.pkg_resourcesr Z getLogger__name__r, r< r" r" r" r# s
PK ! ;'9 9 # __pycache__/prepare.cpython-310.pycnu [ o
ai ] @ s d Z ddlZddlZddlZddlZddlmZmZmZm Z ddl
m Z ddl m
Z
ddlmZ ddlmZmZmZmZmZmZmZ ddlmZ dd lmZ dd
l m Z dd l m Z dd l m!Z!m"Z" dd
l#m$Z$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/m0Z0 ddl1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z; ddle?Z@de)de+dedeAd ef
d d ZBd e d eCd dfd!d"ZDG d#d$ d$ZE d:d e d%e"d&e eC d'e e/ d eEf
d(d)ZFd*eCd+eCd dfd,d-ZGd.eCd/eCd dfd0d1ZH d:d e d&e eC d'e e/ d eEfd2d3ZI d:d e d eCd%e"d&e eC d'e e/ d e eE f d4d5ZJd e d&eCd'e e/ d e eC fd6d7ZKG d8d9 d9ZLdS );z)Prepares a distribution for installation
N)DictIterableListOptional)canonicalize_name))make_distribution_for_install_requirement)InstalledDistribution)DirectoryUrlHashUnsupported HashMismatch HashUnpinnedInstallationErrorNetworkConnectionErrorPreviousBuildDirErrorVcsHashUnsupported)
PackageFinder)BaseDistribution)Link)Wheel)BatchDownloader
Downloader)HTTPRangeRequestUnsupporteddist_from_wheel_url)
PipSession)InstallRequirement)RequirementTracker) copy2_fixed)Hashes
MissingHashes)
indent_log) display_pathhide_urlis_installable_dirrmtree)
TempDirectory) unpack_file)vcsreq req_trackerfinderbuild_isolationreturnc C sL t | }|| ||| W d | S 1 s w Y | S )z(Prepare a distribution for installation.N)r track prepare_distribution_metadataget_metadata_distribution)r& r' r( r)
abstract_dist r/ /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/prepare.py_get_prepared_distribution1 s
r1 linklocationc C s0 t | j}|d us J |j|t| jd d S )N)url)r% get_backend_for_schemeschemeunpackr r4 )r2 r3 vcs_backendr/ r/ r0 unpack_vcs_link> s r9 c @ s& e Zd Zdedee ddfddZdS )Filepath content_typer* Nc C s, || _ |d u rt|d | _d S || _d S )Nr )r; mimetypes
guess_typer< )selfr; r< r/ r/ r0 __init__E s
z
File.__init__)__name__
__module__ __qualname__strr r@ r/ r/ r/ r0 r: D s r: download download_dirhashesc C sV t ddd}d }|rt| ||}|r|}d }n|| |j\}}|r&|| t||S )Nr7 Tkindglobally_managed)r# _check_download_dirr; check_against_pathr: )r2 rE rF rG temp_diralready_downloaded_path from_pathr< r/ r/ r0 get_http_urlM s
rP srcdestc
C sN zt | | W dS tjy& } ztdt|| | W Y d}~dS d}~ww )zCopying special files is not supported, but as a convenience to users
we skip errors copying them. This supports tools that may create e.g.
socket files in the project source directory.
z>Ignoring special file error '%s' encountered copying %s to %s.N)r shutilSpecialFileErrorloggerwarningrD )rQ rR er/ r/ r0 _copy2_ignoring_special_filese s rX sourcetargetc sb t j|}t j|t j|dtdtt dtt f fdd }tj ||dt d d S )Ndnamesr* c s6 g }| kr |ddg7 }t j| kr|g7 }|S )Nz.toxz.nox)osr; abspath)r[ r\ skippedrY target_basenametarget_dirnamer/ r0 ignore~ s
z!_copy_source_tree..ignoreT)rc symlinks
copy_function)
r] r; r^ basenamedirnamerD r rS copytreerX )rY rZ target_abspathrc r/ r` r0 _copy_source_treey s &
rj c C s< d}|r
t | ||}|r|}n| j}|r|| t|dS )z'Get file and optionally check its hash.N)rK file_pathrL r: )r2 rF rG rN rO r/ r/ r0 get_file_url s
rl c C s | j r
t| | dS | r tj|rt| t| j| dS | j r+t
| ||d}nt | |||d}| j s>t
|j||j |S )a_ Unpack link into location, downloading if required.
:param hashes: A Hashes object, one of whose embedded hashes must match,
or HashMismatch will be raised. If the Hashes is empty, no matches are
required, and unhashable types of requirements (like VCS ones, which
would ordinarily raise HashUnsupported) are allowed.
N)rG )is_vcsr9 is_existing_dirr] r; isdirr" rj rk is_filerl rP is_wheelr$ r< )r2 r3 rE rF rG filer/ r/ r0
unpack_url s&
rs c C sp t j|| j}t j|sdS td| |r6z|| W |S ty5 t d| t
| Y dS w |S )zCheck download_dir for previously downloaded file with correct hash
If a correct file is found return its path else None
Nz File was already downloaded %sz;Previously-downloaded file %s has bad hash. Re-downloading.) r] r; joinfilenameexistsrU inforL r
rV unlink)r2 rF rG
download_pathr/ r/ r0 rK s"
rK c sP e Zd ZdZdedee dededededed e d
ed ed ed
eddf fdd Z
de ddfddZ de deddfddZ
de defddZdedee fdd Z d/d ee deddfd d Z d/de dedefd!d"Z d/d#ee deddfd$d%Zde dedefd&d'Zde ddfd(d)Zde defd*d+Zde d,edefd-d.Z ZS )0RequirementPreparerzPrepares a Requirement build_dirrF src_dirr) r' session progress_barr( require_hashes
use_user_site
lazy_wheel
in_tree_buildr* Nc
st t || _|| _|| _|| _t||| _t||| _ || _
|| _ || _ | | _
|
| _| | _| | _i | _d| _d S )N) r )superr@ r| r{ r' _sessionr _downloadr _batch_downloadr( rF r) r r use_lazy_wheelr _downloaded _previous_requirement_header)
r? r{ rF r| r) r' r} r~ r( r r r r __class__r/ r0 r@ s
z RequirementPreparer.__init__r& c C s |j jr|jsd}tt|j j}n d}t|jp|}||f| jkr-||f| _t || |jrNt
t d|j j W d dS 1 sGw Y dS dS )z3Provide context for the requirement being prepared.z
Processing %sz
Collecting %szUsing cached %sN) r2 rp original_link_is_in_wheel_cacherD r rk r& r rU rw r ru )r? r& message informationr/ r/ r0 _log_preparing_link3 s
"z'RequirementPreparer._log_preparing_linkparallel_buildsc C sj |j jrdS |jdu s
J |j r | jr |j j|_dS |j| jd|d t|jr3t d
||jdS )z1Ensure source_dir of a linked InstallRequirement.NT)
autodeleter zpip can't proceed with requirements '{}' due to apre-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.) r2 rq
source_dirrn r rk ensure_has_source_dirr{ r! r format)r? r& r r/ r/ r0 _ensure_link_req_src_dirD s"
z,RequirementPreparer._ensure_link_req_src_dirc C sX | j s |jddS |jjrt |j rt |jd u r#|js#t |jddp+t
S )NT)trust_internetF) r rG r2 rm r rn r
original_link is_pinnedr r )r? r& r/ r/ r0 _get_linked_req_hashesi s
z*RequirementPreparer._get_linked_req_hashesr2 c C s | j sdS | jrtd dS |js|js td| dS t|j}t|j }t
d||j |j
ddd }zt||| jW S tyP td| Y dS w ) z-Fetch metadata using lazy wheel, if possible.Nz3Lazy wheel is not used as hash checking is requiredz>Lazy wheel is not used as %r does not points to a remote wheelz+Obtaining dependency information from %s %s# r z"%s does not support range requests)r r rU debugrp rq r ru r namerw versionr4 splitr r r )r? r2 wheelr r4 r/ r/ r0 _fetch_metadata_using_lazy_wheel s2
z4RequirementPreparer._fetch_metadata_using_lazy_wheelFpartially_downloaded_reqsc
C s t dddj}i }|D ] }|jsJ |||j< q | | |}|D ]\}\}} td|| || }||_q"|D ]}| || q9dS )z>Download any requirements which were only fetched by metadata.r7 TrH zDownloading link %s to %sN) r# r; r2 r keysrU r local_file_path_prepare_linked_requirement)
r? r r rM links_to_fully_downloadr& batch_downloadr2 filepath_r/ r/ r0 _complete_partial_requirements s
z2RequirementPreparer._complete_partial_requirementsc C s |j sJ |j }| | t F d}| jdur(|jr(| |}t|j | j|}|dur4|| j|j j< n| |}|durId|_
|W d S | ||W d S 1 sYw Y dS )z3Prepare a requirement to be obtained from req.link.NT) r2 r r rF rq r rK r r4 r needs_more_preparationr )r? r& r r2 rk rG
wheel_distr/ r/ r0 prepare_linked_requirement s"
$z.RequirementPreparer.prepare_linked_requirementreqsc C s dd |D }|D ]&}| j dur/|jjr/| |}t|j| j |}|dur/|| j|jj< d|_q g }|D ]}|jr?|| q4| || q4| j
||d dS )z,Prepare linked requirements more, if needed.c S s g | ]}|j r|qS r/ )r ).0r& r/ r/ r0
s zHRequirementPreparer.prepare_linked_requirements_more..NF)r ) rF r2 rq r rK r r4 r appendr r )r? r r r& rG rk r r/ r/ r0 prepare_linked_requirements_more s$
z4RequirementPreparer.prepare_linked_requirements_morec
C s |j sJ |j }| || | |}| r | jr d }n<|j| jvrFz
t||j| j | j
|}W n( t yE } z t d
|||d }~ww | j|j }|rS|| t|d d}|r_|j|_t|| j| j| j}|S )NzDCould not install requirement {} because of HTTP error {} for URL {})r< )r2 r r rn r r4 r rs r r rF r
r r rL r: r; r r1 r' r( r) ) r? r& r r2 rG
local_fileexcrk distr/ r/ r0 r s>
z/RequirementPreparer._prepare_linked_requirementc C s | j d usJ |jd usJ |j}|js| r#|jr#|| j d S | r/td| d S |jd u r6d S t j
| j |j }t j
|sXt|j| t|}td| d S d S )NzENot copying link to destination directory since it is a directory: %szSaved %s)rF r2 rm rn editablearchiverU r r r] r; rt ru rv rS copyr rw )r? r& r2 download_locationry r/ r/ r0 save_linked_requirement* s(
z+RequirementPreparer.save_linked_requirementc C s |j sJ dtd| t - | jrtd||| j | t
|| j | j | j
}|| j W d |S 1 s@w Y |S )z Prepare an editable requirement.z-cannot prepare a non-editable req as editablez Obtaining %szoThe editable requirement {} cannot be installed when requiring hashes, because there is no single file to hash.N)r rU rw r r r r r r| update_editabler1 r' r( r) check_if_existsr )r? r& r r/ r/ r0 prepare_editable_requirementD s*
z0RequirementPreparer.prepare_editable_requirement skip_reasonc C s |j sJ d|dusJ d|j td|||j j t | jr)td t| W d S 1 s9w Y dS )z)Prepare an already-installed requirement.z(req should have been satisfied but isn'tNzAdid not get skip reason skipped but req.satisfied_by is set to {}zRequirement %s: %s (%s)zSince it is already installed, we are trusting this package without checking its hash. To ensure a completely repeatable environment, install into an empty virtualenv.)
satisfied_byr rU rw r r r r r r- )r? r& r r/ r/ r0 prepare_installed_requirementb s
$z1RequirementPreparer.prepare_installed_requirement)F) rA rB rC __doc__rD r boolr r r r@ r r r r r r r r r r r r r r r r
__classcell__r/ r/ r r0 rz s
2
%
"
!
(
rz )NN)Mr loggingr= r] rS typingr r r r pip._vendor.packaging.utilsr pip._internal.distributionsr %pip._internal.distributions.installedr pip._internal.exceptionsr r
r r r
r r "pip._internal.index.package_finderr pip._internal.metadatar pip._internal.models.linkr pip._internal.models.wheelr pip._internal.network.downloadr r pip._internal.network.lazy_wheelr r pip._internal.network.sessionr pip._internal.req.req_installr pip._internal.req.req_trackerr pip._internal.utils.filesystemr pip._internal.utils.hashesr r pip._internal.utils.loggingr pip._internal.utils.miscr r r! r" pip._internal.utils.temp_dirr# pip._internal.utils.unpackingr$ pip._internal.vcsr% getLoggerrA rU r r1 rD r9 r: rP rX rj rl rs rK rz r/ r/ r/ r0 s $
6
PK ! 3S5^ ^ " __pycache__/freeze.cpython-310.pycnu [ o
ai*& @ sB d dl Z d dlZd dlZd dlmZmZmZmZmZm Z m
Z
m Z d dl m
Z
d dlmZ d dlmZmZ d dlmZmZ d dlmZmZ d dlmZ d d lm Z e e Z G d
d d e Z
d de
ee! de"de"de
ee! de"de"dee! dee! fddZ#dede!fddZ$dede fdd Z%G d d d Z&dS ) N) ContainerDictIterableIteratorList
NamedTupleOptionalSet)canonicalize_name)Version)
BadCommandInstallationError)BaseDistributionget_environment)install_req_from_editableinstall_req_from_line)
COMMENT_RE)%direct_url_as_pep440_direct_referencec @ s" e Zd ZU eed< ee ed< dS )
_EditableInfo requirementcommentsN)__name__
__module__ __qualname__str__annotations__r r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/freeze.pyr s
r Fr r
local_only user_onlypathsisolatedexclude_editableskipreturnc c s^ i }t |j|d|d}|D ]} t| }
|r |
jr q|
||
j< q| rt } tt } | D ]}
t
|
}|D ]}| rJ| dsJ| dr[|
}|| vrZ| | |V q8| dse| dr| drs|dd }n
|tdd d}t||d }n ttd
| |d }|jstd |
| td q8t|j}||vr| |j std
|
td
| |j q8| |j |
q8t||
V ||= | |j |
q8W d n1 sw Y q/| D ]\}}t|dkrtd|d t t| qdV t | dd dD ]}|j|vr+t|
V q d S )Nr )r r# r #) z-rz
--requirementz-fz --find-linksz-iz --index-urlz--prez--trusted-hostz--process-dependency-linksz--extra-index-urlz
--use-featurez-ez
--editable =)r! zWSkipping line in requirement file [%s] because it's not clear what it would install: %sz9 (add #egg=PackageName to the URL to avoid this warning)zBRequirement file [%s] contains %s, but package %r is not installed z+Requirement %s included multiple times [%s]z, z7## The following requirements were added by pip freeze:c S s
| j S N)namelower)xr r r s
zfreeze..)key) r iter_installed_distributionsFrozenRequirement from_disteditablecanonical_nameset collections defaultdictlistopenstrip
startswithrstripaddlenlstripr r r subr+ loggerinfor
warningappendr itemsjoinsortedvalues)r r r r r! r" r# Z
installationsdistsdistreqZemitted_optionsZ req_filesZ
req_file_pathreq_filelineZline_reqZline_req_canonical_namer+ filesZ installationr r r freeze s
K rO rJ c C s0 t | jtr| j d| j S | j d| j S )Nz==z===)
isinstanceversionr raw_name)rJ r r r _format_as_name_version s rS c
C s | j }|sJ tjtj|}ddlm}m}m} | |}|du r:t
| }t d|| t
|d| dgdS t|j}z ||| j} W nq |yc t
| }t
|d| d | dgd Y S |y }
z t
| }t
|d| d
| d d |
j d
gdW Y d}
~
S d}
~
w ty t d||j t
|g d Y S ty } z t d| W Y d} ~ n d} ~ ww t
| g dS t d| t
|dgdS )za
Compute and return values (req, comments) for use in
FrozenRequirement.from_dist().
r )RemoteNotFoundErrorRemoteNotValidErrorvcsNz1No VCS found for editable requirement "%s" in: %rz,# Editable install with no version control ())r r z # Editable z install with no remote (z
install (z4) with either a deleted local remote or invalid URI:z# ''zPcannot determine version of editable source in %s (%s command not found in path)z6Error when trying to get requirement for VCS system %sz-Could not determine repository location of %sz-## !! Could not determine repository location)editable_project_locationospathnormcaseabspathpip._internal.vcsrT rU rV get_backend_for_dirrS rA debugr typer get_src_requirementrR urlr rC r+ r
) rJ rY locationrT rU rV vcs_backendZdisplayZvcs_namerK exexcr r r _get_editable_info sf
rh c @ sV e Zd Z ddedededee ddf
dd Zed
edd fd d Z defd
dZ
dS )r1 r r+ rK r3 r r$ Nc C s& || _ t|| _|| _|| _|| _d S r* )r+ r
r4 rK r3 r )selfr+ rK r3 r r r r __init__ s
zFrozenRequirement.__init__rJ c C sN |j }|r t|\}}ng }|j}|rt||j}nt|}| |j|||dS )N)r )r3 rh
direct_urlr rR rS )clsrJ r3 rK r rk r r r r2 s zFrozenRequirement.from_distc C s4 | j }| jr d| }dt| jt|g d S )Nz-e
)rK r3 rF r8 r r )ri rK r r r __str__ s
zFrozenRequirement.__str__)r ) r r r r boolr rj classmethodr r2 rn r r r r r1 s
r1 )NFFNFFr )'r6 loggingrZ typingr r r r r r r r pip._vendor.packaging.utilsr
Z pip._vendor.packaging.versionr pip._internal.exceptionsr r
pip._internal.metadatar r pip._internal.req.constructorsr r Zpip._internal.req.req_filer &pip._internal.utils.direct_url_helpersr getLoggerr rA r r ro rO rS rh r1 r r r r sP (
yBPK ! # $ __pycache__/__init__.cpython-310.pycnu [ o
ai @ s d S )N r r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/__init__.py s PK ! S, ! __pycache__/check.cpython-310.pycnu [ o
ai @ s d Z ddlZddlmZmZmZmZmZmZm Z ddl
m Z ddl m
Z
mZ ddlmZ ddlmZ ddlmZ dd lmZ eeZG d
d d eZee
ef Ze e
e f Z e e
ee f Z ee
ee f Z ee
ee f Z e e e f Z e ee f Z!d e ee"f fd
dZ# ddedeee$ge"f d e fddZ%dee d e!fddZ&dee ded ee
fddZ'dee
ded ee
fddZ(dS ) z'Validation of dependencies of packages
N)CallableDictList
NamedTupleOptionalSetTuple) Requirement)NormalizedNamecanonicalize_name))make_distribution_for_install_requirement)get_default_environment)DistributionVersion)InstallRequirementc @ s" e Zd ZU eed< ee ed< dS )PackageDetailsversion dependenciesN)__name__
__module__ __qualname__r __annotations__r r r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/check.pyr s
r returnc C s i } d}t }|jdddD ]2}|j}zt| }t|j|| |< W q ttfy@ } zt
d|| d}W Y d}~qd}~ww | |fS )z3Converts a list of distributions into a PackageSet.Fr )
local_onlyskipz%Error parsing requirements for %s: %sTN) r
iter_installed_distributionscanonical_namelistiter_dependenciesr r OSError
ValueErrorloggerwarning) package_setproblemsenvdistnamer er r r !create_package_set_from_installed" s r* r$
should_ignorec C s i }i }| D ]_\}}t }t }|r||rq|jD ]6}t|j} | | vr=d}
|jdur3|j }
|
r<|| |f q | | j} |j j
| ddsR|| | |f q |r]t |t d||< |rgt |t d||< q||fS )zCheck if a package set is consistent
If should_ignore is passed, it should be a callable that takes a
package name and returns a boolean.
TN) prereleases)key)
itemssetr r r( markerevaluateaddr specifiercontainssortedstr) r$ r+ missing conflicting package_namepackage_detail missing_depsconflicting_depsreqr( missedr r r r check_package_set3 s4
r?
to_installc s6 t \}}t| |}t|| |t| fdddfS )zeFor checking if the dependency graph would be consistent after installing given requirements
c s | vS Nr )r( whitelistr r o s z)check_install_conflicts..)r+ )r* _simulate_installation_of_create_whitelistr? )r@ r$ _would_be_installedr rB r check_install_conflicts` s
rI c C sL t }| D ] }t|}| }|j}t|jt| ||< || q|S )z=Computes the version of packages after installing to_install.) r/ r get_metadata_distributionr r r r r r2 )r@ r$ installedinst_req
abstract_distr' r( r r r rE t s rE rH c C sL t | }|D ] }||v r
q|| jD ]}t|j|v r"|| nqq|S rA )r/ r r r( r2 )rH r$ packages_affectedr9 r= r r r rF s
rF rA ))__doc__loggingtypingr r r r r r r Z"pip._vendor.packaging.requirementsr pip._vendor.packaging.utilsr
r pip._internal.distributionsr pip._internal.metadatar
Zpip._internal.metadata.baser pip._internal.req.req_installr getLoggerr r" r
PackageSetMissing Conflicting MissingDictConflictingDict CheckResultConflictDetailsboolr* r6 r? rI rE rF r r r r sT $
-
PK ! :e ] ]
prepare.pynu [ """Prepares a distribution for installation
"""
# The following comment should be removed at some point in the future.
# mypy: strict-optional=False
import logging
import mimetypes
import os
import shutil
from typing import Dict, Iterable, List, Optional
from pip._vendor.packaging.utils import canonicalize_name
from pip._internal.distributions import make_distribution_for_install_requirement
from pip._internal.distributions.installed import InstalledDistribution
from pip._internal.exceptions import (
DirectoryUrlHashUnsupported,
HashMismatch,
HashUnpinned,
InstallationError,
NetworkConnectionError,
PreviousBuildDirError,
VcsHashUnsupported,
)
from pip._internal.index.package_finder import PackageFinder
from pip._internal.metadata import BaseDistribution
from pip._internal.models.link import Link
from pip._internal.models.wheel import Wheel
from pip._internal.network.download import BatchDownloader, Downloader
from pip._internal.network.lazy_wheel import (
HTTPRangeRequestUnsupported,
dist_from_wheel_url,
)
from pip._internal.network.session import PipSession
from pip._internal.req.req_install import InstallRequirement
from pip._internal.req.req_tracker import RequirementTracker
from pip._internal.utils.filesystem import copy2_fixed
from pip._internal.utils.hashes import Hashes, MissingHashes
from pip._internal.utils.logging import indent_log
from pip._internal.utils.misc import display_path, hide_url, is_installable_dir, rmtree
from pip._internal.utils.temp_dir import TempDirectory
from pip._internal.utils.unpacking import unpack_file
from pip._internal.vcs import vcs
logger = logging.getLogger(__name__)
def _get_prepared_distribution(
req: InstallRequirement,
req_tracker: RequirementTracker,
finder: PackageFinder,
build_isolation: bool,
) -> BaseDistribution:
"""Prepare a distribution for installation."""
abstract_dist = make_distribution_for_install_requirement(req)
with req_tracker.track(req):
abstract_dist.prepare_distribution_metadata(finder, build_isolation)
return abstract_dist.get_metadata_distribution()
def unpack_vcs_link(link: Link, location: str) -> None:
vcs_backend = vcs.get_backend_for_scheme(link.scheme)
assert vcs_backend is not None
vcs_backend.unpack(location, url=hide_url(link.url))
class File:
def __init__(self, path: str, content_type: Optional[str]) -> None:
self.path = path
if content_type is None:
self.content_type = mimetypes.guess_type(path)[0]
else:
self.content_type = content_type
def get_http_url(
link: Link,
download: Downloader,
download_dir: Optional[str] = None,
hashes: Optional[Hashes] = None,
) -> File:
temp_dir = TempDirectory(kind="unpack", globally_managed=True)
# If a download dir is specified, is the file already downloaded there?
already_downloaded_path = None
if download_dir:
already_downloaded_path = _check_download_dir(link, download_dir, hashes)
if already_downloaded_path:
from_path = already_downloaded_path
content_type = None
else:
# let's download to a tmp dir
from_path, content_type = download(link, temp_dir.path)
if hashes:
hashes.check_against_path(from_path)
return File(from_path, content_type)
def _copy2_ignoring_special_files(src: str, dest: str) -> None:
"""Copying special files is not supported, but as a convenience to users
we skip errors copying them. This supports tools that may create e.g.
socket files in the project source directory.
"""
try:
copy2_fixed(src, dest)
except shutil.SpecialFileError as e:
# SpecialFileError may be raised due to either the source or
# destination. If the destination was the cause then we would actually
# care, but since the destination directory is deleted prior to
# copy we ignore all of them assuming it is caused by the source.
logger.warning(
"Ignoring special file error '%s' encountered copying %s to %s.",
str(e),
src,
dest,
)
def _copy_source_tree(source: str, target: str) -> None:
target_abspath = os.path.abspath(target)
target_basename = os.path.basename(target_abspath)
target_dirname = os.path.dirname(target_abspath)
def ignore(d: str, names: List[str]) -> List[str]:
skipped: List[str] = []
if d == source:
# Pulling in those directories can potentially be very slow,
# exclude the following directories if they appear in the top
# level dir (and only it).
# See discussion at https://github.com/pypa/pip/pull/6770
skipped += [".tox", ".nox"]
if os.path.abspath(d) == target_dirname:
# Prevent an infinite recursion if the target is in source.
# This can happen when TMPDIR is set to ${PWD}/...
# and we copy PWD to TMPDIR.
skipped += [target_basename]
return skipped
shutil.copytree(
source,
target,
ignore=ignore,
symlinks=True,
copy_function=_copy2_ignoring_special_files,
)
def get_file_url(
link: Link, download_dir: Optional[str] = None, hashes: Optional[Hashes] = None
) -> File:
"""Get file and optionally check its hash."""
# If a download dir is specified, is the file already there and valid?
already_downloaded_path = None
if download_dir:
already_downloaded_path = _check_download_dir(link, download_dir, hashes)
if already_downloaded_path:
from_path = already_downloaded_path
else:
from_path = link.file_path
# If --require-hashes is off, `hashes` is either empty, the
# link's embedded hash, or MissingHashes; it is required to
# match. If --require-hashes is on, we are satisfied by any
# hash in `hashes` matching: a URL-based or an option-based
# one; no internet-sourced hash will be in `hashes`.
if hashes:
hashes.check_against_path(from_path)
return File(from_path, None)
def unpack_url(
link: Link,
location: str,
download: Downloader,
download_dir: Optional[str] = None,
hashes: Optional[Hashes] = None,
) -> Optional[File]:
"""Unpack link into location, downloading if required.
:param hashes: A Hashes object, one of whose embedded hashes must match,
or HashMismatch will be raised. If the Hashes is empty, no matches are
required, and unhashable types of requirements (like VCS ones, which
would ordinarily raise HashUnsupported) are allowed.
"""
# non-editable vcs urls
if link.is_vcs:
unpack_vcs_link(link, location)
return None
# Once out-of-tree-builds are no longer supported, could potentially
# replace the below condition with `assert not link.is_existing_dir`
# - unpack_url does not need to be called for in-tree-builds.
#
# As further cleanup, _copy_source_tree and accompanying tests can
# be removed.
#
# TODO when use-deprecated=out-of-tree-build is removed
if link.is_existing_dir():
if os.path.isdir(location):
rmtree(location)
_copy_source_tree(link.file_path, location)
return None
# file urls
if link.is_file:
file = get_file_url(link, download_dir, hashes=hashes)
# http urls
else:
file = get_http_url(
link,
download,
download_dir,
hashes=hashes,
)
# unpack the archive to the build dir location. even when only downloading
# archives, they have to be unpacked to parse dependencies, except wheels
if not link.is_wheel:
unpack_file(file.path, location, file.content_type)
return file
def _check_download_dir(
link: Link, download_dir: str, hashes: Optional[Hashes]
) -> Optional[str]:
"""Check download_dir for previously downloaded file with correct hash
If a correct file is found return its path else None
"""
download_path = os.path.join(download_dir, link.filename)
if not os.path.exists(download_path):
return None
# If already downloaded, does its hash match?
logger.info("File was already downloaded %s", download_path)
if hashes:
try:
hashes.check_against_path(download_path)
except HashMismatch:
logger.warning(
"Previously-downloaded file %s has bad hash. Re-downloading.",
download_path,
)
os.unlink(download_path)
return None
return download_path
class RequirementPreparer:
"""Prepares a Requirement"""
def __init__(
self,
build_dir: str,
download_dir: Optional[str],
src_dir: str,
build_isolation: bool,
req_tracker: RequirementTracker,
session: PipSession,
progress_bar: str,
finder: PackageFinder,
require_hashes: bool,
use_user_site: bool,
lazy_wheel: bool,
in_tree_build: bool,
) -> None:
super().__init__()
self.src_dir = src_dir
self.build_dir = build_dir
self.req_tracker = req_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 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
# Should in-tree builds be used for local paths?
self.in_tree_build = in_tree_build
# 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 = ("", "")
def _log_preparing_link(self, req: InstallRequirement) -> None:
"""Provide context for the requirement being prepared."""
if req.link.is_file and not req.original_link_is_in_wheel_cache:
message = "Processing %s"
information = str(display_path(req.link.file_path))
else:
message = "Collecting %s"
information = str(req.req or req)
if (message, information) != self._previous_requirement_header:
self._previous_requirement_header = (message, information)
logger.info(message, information)
if req.original_link_is_in_wheel_cache:
with indent_log():
logger.info("Using cached %s", req.link.filename)
def _ensure_link_req_src_dir(
self, req: InstallRequirement, parallel_builds: bool
) -> 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() and self.in_tree_build:
# 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)
)
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 req.original_link is None 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()
def _fetch_metadata_using_lazy_wheel(
self,
link: Link,
) -> Optional[BaseDistribution]:
"""Fetch metadata using lazy wheel, if possible."""
if not self.use_lazy_wheel:
return None
if self.require_hashes:
logger.debug("Lazy wheel is not used as hash checking is required")
return None
if link.is_file or not link.is_wheel:
logger.debug(
"Lazy wheel is not used as %r does not points 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
def _complete_partial_requirements(
self,
partially_downloaded_reqs: Iterable[InstallRequirement],
parallel_builds: bool = False,
) -> 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
# 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)
def prepare_linked_requirement(
self, req: InstallRequirement, parallel_builds: bool = False
) -> BaseDistribution:
"""Prepare a requirement to be obtained from req.link."""
assert req.link
link = 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 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:
# 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
wheel_dist = self._fetch_metadata_using_lazy_wheel(link)
if wheel_dist is not None:
req.needs_more_preparation = True
return wheel_dist
# None of the optimizations worked, fully prepare the requirement
return self._prepare_linked_requirement(req, parallel_builds)
def prepare_linked_requirements_more(
self, reqs: Iterable[InstallRequirement], parallel_builds: bool = False
) -> 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,
)
def _prepare_linked_requirement(
self, req: InstallRequirement, parallel_builds: bool
) -> BaseDistribution:
assert req.link
link = req.link
self._ensure_link_req_src_dir(req, parallel_builds)
hashes = self._get_linked_req_hashes(req)
if link.is_existing_dir() and self.in_tree_build:
local_file = None
elif link.url not in self._downloaded:
try:
local_file = unpack_url(
link, req.source_dir, self._download, 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)
# 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.req_tracker,
self.finder,
self.build_isolation,
)
return dist
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)
def prepare_editable_requirement(
self,
req: InstallRequirement,
) -> 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()
dist = _get_prepared_distribution(
req,
self.req_tracker,
self.finder,
self.build_isolation,
)
req.check_if_exists(self.use_user_site)
return dist
def prepare_installed_requirement(
self,
req: InstallRequirement,
skip_reason: str,
) -> 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()
PK ! > > install/legacy.pynu [ """Legacy installation process, i.e. `setup.py install`.
"""
import logging
import os
from distutils.util import change_root
from typing import List, Optional, Sequence
from pip._internal.build_env import BuildEnvironment
from pip._internal.exceptions import InstallationError
from pip._internal.models.scheme import Scheme
from pip._internal.utils.logging import indent_log
from pip._internal.utils.misc import ensure_dir
from pip._internal.utils.setuptools_build import make_setuptools_install_args
from pip._internal.utils.subprocess import runner_with_spinner_message
from pip._internal.utils.temp_dir import TempDirectory
logger = logging.getLogger(__name__)
class LegacyInstallFailure(Exception):
pass
def write_installed_files_from_setuptools_record(
record_lines: List[str],
root: Optional[str],
req_description: str,
) -> None:
def prepend_root(path: str) -> str:
if root is None or not os.path.isabs(path):
return path
else:
return change_root(root, path)
for line in record_lines:
directory = os.path.dirname(line)
if directory.endswith(".egg-info"):
egg_info_dir = prepend_root(directory)
break
else:
message = (
"{} did not indicate that it installed an "
".egg-info directory. Only setup.py projects "
"generating .egg-info directories are supported."
).format(req_description)
raise InstallationError(message)
new_lines = []
for line in record_lines:
filename = line.strip()
if os.path.isdir(filename):
filename += os.path.sep
new_lines.append(os.path.relpath(prepend_root(filename), egg_info_dir))
new_lines.sort()
ensure_dir(egg_info_dir)
inst_files_path = os.path.join(egg_info_dir, "installed-files.txt")
with open(inst_files_path, "w") as f:
f.write("\n".join(new_lines) + "\n")
def install(
install_options: List[str],
global_options: Sequence[str],
root: Optional[str],
home: Optional[str],
prefix: Optional[str],
use_user_site: bool,
pycompile: bool,
scheme: Scheme,
setup_py_path: str,
isolated: bool,
req_name: str,
build_env: BuildEnvironment,
unpacked_source_directory: str,
req_description: str,
) -> bool:
header_dir = scheme.headers
with TempDirectory(kind="record") as temp_dir:
try:
record_filename = os.path.join(temp_dir.path, "install-record.txt")
install_args = make_setuptools_install_args(
setup_py_path,
global_options=global_options,
install_options=install_options,
record_filename=record_filename,
root=root,
prefix=prefix,
header_dir=header_dir,
home=home,
use_user_site=use_user_site,
no_user_config=isolated,
pycompile=pycompile,
)
runner = runner_with_spinner_message(
f"Running setup.py install for {req_name}"
)
with indent_log(), build_env:
runner(
cmd=install_args,
cwd=unpacked_source_directory,
)
if not os.path.exists(record_filename):
logger.debug("Record file %s not found", record_filename)
# Signal to the caller that we didn't install the new package
return False
except Exception as e:
# Signal to the caller that we didn't install the new package
raise LegacyInstallFailure from e
# At this point, we have successfully installed the requirement.
# We intentionally do not use any encoding to read the file because
# setuptools writes the file using distutils.file_util.write_file,
# which does not specify an encoding.
with open(record_filename) as f:
record_lines = f.read().splitlines()
write_installed_files_from_setuptools_record(record_lines, root, req_description)
return True
PK ! > * install/__pycache__/legacy.cpython-310.pycnu [ o
ai> @ s. d Z ddlZddlZddlmZ ddlmZmZmZ ddl m
Z
ddl m Z ddl
mZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ eeZG d
d de Z dee dee de ddfddZ dee dee dee dee dee de de ded e d e d e d e
d e de de f d!d"Z!dS )#z6Legacy installation process, i.e. `setup.py install`.
N) change_root)ListOptionalSequence)BuildEnvironment)InstallationError)Scheme)
indent_log)
ensure_dir) make_setuptools_install_args)runner_with_spinner_message)
TempDirectoryc @ s e Zd ZdS )LegacyInstallFailureN)__name__
__module__ __qualname__ r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/install/legacy.pyr s r record_linesrootreq_descriptionreturnc s dt dt f fdd }| D ]}tj|}|dr ||} n
q
d|}t|g }| D ] }| } tj| r@| tjj 7 } |
tj || | q.| t
| tj|d}
t|
d} | d |d W d d S 1 sww Y d S )
Npathr c s" d u s
t j| s | S t | S )N)osr isabsr )r r r r prepend_root s
zBwrite_installed_files_from_setuptools_record..prepend_rootz .egg-infoz{} did not indicate that it installed an .egg-info directory. Only setup.py projects generating .egg-info directories are supported.zinstalled-files.txtw
)strr r dirnameendswithformatr stripisdirsepappendrelpathsortr
joinopenwrite) r r r r line directory egg_info_dirmessage new_linesfilenameinst_files_pathfr r r ,write_installed_files_from_setuptools_record s.
"r4 install_optionsglobal_optionshomeprefix
use_user_site pycompilescheme
setup_py_pathisolatedreq_name build_envunpacked_source_directoryc C sT |j }tdd}z`tj|jd}t||| ||||||| |d }td|
}t | ||| d W d n1 s?w Y W d n1 sNw Y tj|sht
d| W W d dS W n t yx } zt |d }~ww t
|}| }W d n1 sw Y W d n1 sw Y t|||
d S )
Nrecord)kindzinstall-record.txt)
r6 r5 record_filenamer r8
header_dirr7 r9 no_user_configr: z Running setup.py install for )cmdcwdzRecord file %s not foundFT)headersr
r r r) r r r existsloggerdebug Exceptionr r* read
splitlinesr4 )r5 r6 r r7 r8 r9 r: r; r< r= r> r? r@ r rD temp_dirrC install_argsrunnerer3 r r r r install> sX
+rS )"__doc__loggingr distutils.utilr typingr r r pip._internal.build_envr pip._internal.exceptionsr pip._internal.models.schemer pip._internal.utils.loggingr pip._internal.utils.miscr
$pip._internal.utils.setuptools_buildr pip._internal.utils.subprocessr pip._internal.utils.temp_dirr
getLoggerr rJ rL r r r4 boolrS r r r r sn
%
PK ! nR R ) install/__pycache__/wheel.cpython-310.pycnu [ o
aik @ s d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
mZ ddlmZ ddlmZmZmZ ddlmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z( ddl)m*Z* dd l+m,Z, dd
l-m.Z. dd l/m0Z0 dd l1m2Z2 dd
l3m4Z4m5Z5m6Z6 ddl7m8Z8m9Z9 ddl:m;Z;mZ>m?Z? ddl@mAZAmBZBmCZCmDZD ddlEmFZFmGZGmHZHmIZI ddlJmKZK erddlmLZL G dd deLZMeNeOZPe deQZRe#eReQe$eSeQf f ZTd[deQdeSde#eQeQf fd d ZUd eQdeeQef fd d ZVdeQdeWfd!d"ZXd#edeWfd$d%ZYd&e4de#eeQeQf eeQeQf f fd'd(ZZd)e!eQ de eQ fd*d+Z[d,e eT de e#eQeQeQf fd-d.Z\d/eRdeQfd0d1Z]d\deQd2e eQ deRfd3d4Z^d5e e eQ d6eeReRf d7e"eR d8e eQ d9eQde eT f d:d;Z_dZ`G d?d@ d@ZaG dAdB dBZbG dCdD dDe0ZcdEeQddfdFdGZdG dHdI dIe*Ze J J Kd]dLeQdMe'dNeQdOe s z5message_about_scripts_not_on_PATH..PATHrQ c s& i | ]\}}t j| vr||qS r8 )rY rF ry )r|
parent_dirrx
not_warn_dirsr8 r;
s
z5message_about_scripts_not_on_PATH.. z script {} isr zscripts {} are, z and z.The {} installed in '{}' which is not on PATH.zeConsider adding {} to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.zthis directoryzthese directoriesc s s | ] }|r|d dkV qdS )r ~Nr8 r{ r8 r8 r; s
z4message_about_scripts_not_on_PATH..ziNOTE: The current PATH contains path(s) starting with `~`, which may not be expanded by all applications.
) collections defaultdictsetrY rF dirnamebasenameaddenvironrl splitpathsepappendry r^ r_ itemssortedlenformatjoinany)
rx grouped_by_dirdestfiler script_namewarn_for msg_lines dir_scriptssorted_scripts
start_text
last_line_fmtwarn_for_tildetilde_warning_msgr8 r r; !message_about_scripts_not_on_PATH sT
r outrowsc C s t dd | D S )a Normalize the given rows of a RECORD file.
Items in each row are converted into str. Rows are then sorted to make
the value more predictable for tests.
Each row is a 3-tuple (path, hash, size) and corresponds to a record of
a RECORD file (see PEP 376 and PEP 427 for details). For the rows
passed to this function, the size can be an integer as an int or string,
or the empty string.
c s s$ | ]
\}}}||t |fV qd S r7 )rC )r| record_pathhash_sizer8 r8 r; r s
z&_normalized_outrows..)r )r r8 r8 r; _normalized_outrows s r r c C s | S r7 r8 )r r8 r8 r; _record_to_fs_path r= r relative_toc C sX |d ur t j| d t j|d kr t j| |} | t jjd} td| S )Nr /r2 )rY rF
splitdriverm relpathr& rz r )rF r r8 r8 r; _fs_to_record_path s
r old_csv_rows installedr5 generatedlib_dirc C s g }| D ]H}t |dkrtd| td|d }|||}||v r,tt|\} }
nt |dkr6|d nd} t |dkrB|d nd}
||| |
f q|D ]} t| |} t| \} }
|| | |
f qO| D ]
}
||
ddf qi|S )z_
:param installed: A map from archive RECORD path to installation RECORD
path.
z,RECORD line has more than three elements: %sr2 r r rQ )
r loggerwarningr poprO r r r values)r r r5 r r installed_rowsrowold_record_pathnew_record_pathrJ rN frF installed_record_pathr8 r8 r; get_csv_rows_for_installed s$
r consolec C s | } g }| dd}|rJdtjvr|d| tjdddkr/|dtjd | |dt d | d
d | D }|D ]}| |= qD| d d}|rwdtjvr^|d
| |dt | dd | D }|D ]}| |= qq|
t dj| |S )zk
Given the mapping from entrypoint name to callable, return the relevant
console script specs.
pipNENSUREPIP_OPTIONSzpip = rQ
altinstallz
pip{} = {}r z = c S g | ]
}t d |r|qS )zpip(\d(\.\d)?)?$rematchr| kr8 r8 r; r~ J s z,get_console_script_specs.. easy_installzeasy_install = zeasy_install-{} = {}c S r )zeasy_install(-\d\.\d)?$r r r8 r8 r; r~ X s
{} = {})
copyr rY r r rl r r^ version_infor extendr r )r scripts_to_generate
pip_scriptpip_epr easy_install_scripteasy_install_epr8 r8 r; get_console_script_specs s< #
r c @ s> e Zd ZdedededdfddZdefdd Zd d
d Z dS )
ZipBackedFiler3 r4 zip_filer6 Nc C s || _ || _|| _d| _d S NF)r3 r4 _zip_filer5 )r: r3 r4 r r8 r8 r; __init__e s
zZipBackedFile.__init__c C s | j | jS r7 )r getinfor3 r9 r8 r8 r; _getinfom s zZipBackedFile._getinfoc C s t j| j}t| t j| jrt | j | }| j |$}t | jd}t
|| W d n1 s:w Y W d n1 sIw Y t |rYt
| j d S d S )NrX )rY rF r r4 r( existsunlinkr r r[ shutil copyfileobjr. r- )r: r zipinfor destr8 r8 r; r< p s
zZipBackedFile.saver> )
r? r@ rA r2 rC r r r r r< r8 r8 r8 r; r d s
r c @ s e Zd Zd ddZd
ddZdS )
ScriptFilefiler1 r6 Nc C s$ || _ | j j| _| j j| _d| _d S r )_filer3 r4 r5 )r: r r8 r8 r; r s
zScriptFile.__init__c C s | j t| j| _d S r7 )r r< ri r4 r5 r9 r8 r8 r; r< s
zScriptFile.save)r r1 r6 Nr> )r? r@ rA r r< r8 r8 r8 r; r s
r c s& e Zd Zdeddf fdd Z ZS )MissingCallableSuffixrv r6 Nc s t d| d S )NzInvalid script entry point: {} - A callable suffix is required. Cf https://packaging.python.org/specifications/entry-points/#use-for-scripts for more information.)superr r )r: rv __class__r8 r; r s z MissingCallableSuffix.__init__)r? r@ rA rC r
__classcell__r8 r8 r r; r s r
specificationc C s. t | }|d ur|jd u rtt|d S d S r7 )r suffixr rC )r entryr8 r8 r; _raise_for_invalid_entrypoint s r c s8 e Zd Zddedeeef dee f fdd
Z ZS )PipScriptMakerNr optionsr6 c s t | t ||S r7 )r r make)r: r r r r8 r; r s zPipScriptMaker.maker7 ) r? r@ rA rC r r r r r r8 r8 r r; r s 0r TFru wheel_zip
wheel_pathscheme pycompilewarn_script_location
direct_url requestedc 8 s( t || \}} t| r|jn|ji t g }
d8dtdtdtddffdd
} d tdtfd
d } d td
tddffdd dtdtdt tgdf f fdd }
dtdt
dt tgdf f fdd }d tdtfdd}t t t |
}t| |}t||\}}|
|}t||}d tdtfdd}t||\}}|||}t||}t||}ttt| }t|\d ddtffd d } t||} t| | } tt| } t|| }|D ]} | | | j| j| j qdtt ffd d } d tdtfd!d"} |rkt Q}!t < t d# | D ]+}"t j!|"d$d$d%}#|#rB| |"}$t"j#$|$s2J t d&|$%t"j#j&d'}%| |%|$ qW d n 1 sOw Y W d n 1 s_w Y t'(|!) t*d|j+}&d$|&_,d(h|&_-d$|&_.t/}'t0t1d)j23 }(|&4|'})|
5|) |
5|&4|(d*d$i |rt6|)}*|*durt'7|* d+t8 @ t9j:d td,t;dtt< ffd-d. }+t"j#=|},t"j#=|,d/}-|+|-
}.|.>d0 W d n 1 sw Y |
?|- |dur$t"j#=|,t@}/|+|/}0|0>|A Bd1 W d n 1 sw Y |
?|/ |rIt"j#=|,d2}1tC|1d3 W d n 1 s?w Y |
?|1 |Dd4}2t0tEF|2G }3tH|3|
d5}4t"j#=|,d4}5|+|5fi tId6}6tEJt d7|6}7|7KtL|4 W d dS 1 sw Y dS )9a Install a wheel.
:param name: Name of the project to install
:param wheel_zip: open ZipFile for wheel being installed
:param scheme: Distutils scheme dictating the install directories
:param req_description: String used in place of the requirement, for
logging
:param pycompile: Whether to byte-compile installed Python files
:param warn_script_location: Whether to check that scripts are installed
into a directory on PATH
:raises UnsupportedWheel:
* when the directory holds an unpacked wheel with incompatible
Wheel-Version
* when the .dist-info dir does not match the wheel
Fsrcfiler modifiedr6 Nc s, t |}|| < |r t | dS dS )z6Map archive RECORD paths to installation RECORD paths.N)r r )r r r newpath)r5 r r r8 r; record_installed s
z(_install_wheel..record_installedrF c S s
| dS )Nr )endswithrF r8 r8 r; is_dir_path s
z#_install_wheel..is_dir_path
dest_dir_path target_pathc s$ t | |sd}t| || d S )NzRThe wheel {!r} has a file {!r} trying to install outside the target directory {!r})r, r r )r r message)r r8 r; assert_no_path_traversal s
z0_install_wheel..assert_no_path_traversalr r r1 c s dt ddf fdd }|S )Nr r6 r1 c s0 t j| }t j|} | t| |S r7 )rY rF normpathr r )r normed_pathr4 )r r r r8 r; make_root_scheme_file s
zM_install_wheel..root_scheme_file_maker..make_root_scheme_file)r2 )r r r )r )r r r; root_scheme_file_maker s z._install_wheel..root_scheme_file_makerr c s2 fddt D dtddffdd }|S )Nc s i | ]}|t |qS r8 )getattr)r| key)r r8 r; r s zB_install_wheel..data_scheme_file_maker..r r6 r1 c s t j| }z
|t jjd\}}}W n ty$ d| }t|w z| }W n tyE d t
}d|| |}t|w t j ||} || t | |S )Nr zbUnexpected file in {}: {!r}. .data directory contents should be named like: '/'.r zUnknown scheme key used in {}: {} (for file {!r}). .data directory contents should be in subdirectories named with a valid scheme key ({})) rY rF r r rz
ValueErrorr r KeyErrorr r r ) r r _
scheme_key dest_subpathr scheme_pathvalid_scheme_keysr4 )r scheme_pathsr r r8 r; make_data_scheme_file s*
zM_install_wheel..data_scheme_file_maker..make_data_scheme_file)r# r2 )r r r )r r )r r r r; data_scheme_file_maker s z._install_wheel..data_scheme_file_makerc S s | ddd dS )Nr r r .data)r r r r8 r8 r; is_data_scheme_path s z+_install_wheel..is_data_scheme_pathc S s2 | dd}t|dko|d do|d dkS )Nr r r r r rx )r r r )rF partsr8 r8 r; is_script_scheme_path" s &z-_install_wheel..is_script_scheme_pathr c sz | j }tj|}| dr|d d }n | dr%|d d }n| dr3|d d }n|}| v p<|v S )Nz.exez
-script.pyiz.pya)r4 rY rF r rm r )r rF ru matchname)r guir8 r; is_entrypoint_wrapper5 s z-_install_wheel..is_entrypoint_wrapperc 3 sJ t t D ]} tj| }tj|sq |ds q |V q d S )Nz.py)r r r rY rF r rZ r )installed_pathfull_installed_path)r r r8 r; pyc_source_file_pathsP s
z-_install_wheel..pyc_source_file_pathsc S s t j| S )z8Return the path the pyc file would have been written to.) importlibutilcache_from_sourcer r8 r8 r; pyc_output_path] s z'_install_wheel..pyc_output_pathignoreT)forcequietr2 r rQ r r i kwargsc ; sV t | fi | }|V W d n1 sw Y t|j t|j| d S r7 )r% rY chmodru r& )rF r' r )generated_file_moder8 r; _generate_file s z&_install_wheel.._generate_file INSTALLERs pip
rR REQUESTEDrX RECORD)r r5 r r wzIO[str])F)Mr/ rn purelibplatlibr r2 rC rD r r r$ r r namelistr r* mapr r r r rw r r< r3 r4 r5 r r' warningscatch_warningsfilterwarnings
compileall compile_filerY rF r r& rz r debuggetvaluer rx clobbervariantsset_moder listr r r
make_multipler r r r+
contextlibcontextmanagerr r
r rd r r! to_jsonr` r[ read_textcsvreader
splitlinesr rU writer writerowsr )8ru r r r r r r r info_dirrj r r r r r r paths
file_pathsroot_scheme_pathsdata_scheme_pathsr filesr other_scheme_pathsscript_scheme_pathsr other_scheme_files distributionr script_scheme_filesr r r# stdoutrF successpyc_pathpyc_record_pathmakerr gui_scripts_to_generategenerated_console_scriptsmsgr*
dest_info_dirinstaller_pathinstaller_filedirect_url_pathdirect_url_filerequested_path record_text record_rowsrowsr record_filerF r8 )r r5 r r) r r r r r; _install_wheel s
!
$re req_descriptionc
c sD zd V W d S t y! } zd| |jd }t ||d }~ww )NzFor req: {}. {}r )r r args)rf er r8 r8 r; req_error_context s
ri c C s t |dd1}t| t| |||||||d W d n1 s"w Y W d d S W d d S 1 s:w Y d S )NT)
allowZip64)ru r r r r r r r )r ri re ) ru r r rf r r r r zr8 r8 r;
install_wheel s
"rl )rE r7 )TTNF)j__doc__r r6 r? rC r loggingos.pathrY r r r^ r3 base64r
email.messager itertoolsr r r typingr r r r
r r r
r r r r r r r r r zipfiler r pip._vendor.distlib.scriptsr Zpip._vendor.distlib.utilr pip._vendor.packaging.utilsr pip._internal.exceptionsr pip._internal.locationsr pip._internal.metadatar r r pip._internal.models.direct_urlr! r" pip._internal.models.schemer# r$ pip._internal.utils.filesystemr% r& pip._internal.utils.miscr' r( r) r* pip._internal.utils.unpackingr+ r, r- r. pip._internal.utils.wheelr/ r0 r1 getLoggerr? r rC r2 intInstalledCSVRowrO rU rD ri rn rw r r r r r r r r r r r re r@ ri rl r8 r8 r8 r; s H
* H
Q(
PK ! 3#
0 0 , install/__pycache__/__init__.cpython-310.pycnu [ o
ai3 @ s d Z dS )z,For modules related to installing packages.
N)__doc__ r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/install/__init__.py s PK ! we 3 install/__pycache__/editable_legacy.cpython-310.pycnu [ o
ai @ s d Z ddlZddlmZmZmZ ddlmZ ddlm Z ddl
m Z ddl m
Z
eeZdee d ee d
ee d ee d ed
edededededdfddZdS )z?Legacy editable installation process, i.e. `setup.py develop`.
N)ListOptionalSequence)BuildEnvironment)
indent_log) make_setuptools_develop_args)call_subprocessinstall_optionsglobal_optionsprefixhome
use_user_sitename
setup_py_pathisolated build_envunpacked_source_directoryreturnc
C s t d| t||| ||||d}
t ) | t|
| d W d n1 s(w Y W d dS W d dS 1 s@w Y dS )z[Install a package in editable mode. Most arguments are pass-through
to setuptools.
z Running setup.py develop for %s)r
r no_user_configr r r
)cwdN)loggerinfor r r ) r r
r r r
r r r r r args r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/install/editable_legacy.pyinstall_editable s(
"r )__doc__loggingtypingr r r pip._internal.build_envr pip._internal.utils.loggingr $pip._internal.utils.setuptools_buildr pip._internal.utils.subprocessr getLogger__name__r strboolr r r r r s>
PK ! Z install/editable_legacy.pynu [ """Legacy editable installation process, i.e. `setup.py develop`.
"""
import logging
from typing import List, Optional, Sequence
from pip._internal.build_env import BuildEnvironment
from pip._internal.utils.logging import indent_log
from pip._internal.utils.setuptools_build import make_setuptools_develop_args
from pip._internal.utils.subprocess import call_subprocess
logger = logging.getLogger(__name__)
def install_editable(
install_options: List[str],
global_options: Sequence[str],
prefix: Optional[str],
home: Optional[str],
use_user_site: bool,
name: str,
setup_py_path: str,
isolated: bool,
build_env: BuildEnvironment,
unpacked_source_directory: str,
) -> None:
"""Install a package in editable mode. Most arguments are pass-through
to setuptools.
"""
logger.info("Running setup.py develop for %s", name)
args = make_setuptools_develop_args(
setup_py_path,
global_options=global_options,
install_options=install_options,
no_user_config=isolated,
prefix=prefix,
home=home,
use_user_site=use_user_site,
)
with indent_log():
with build_env:
call_subprocess(
args,
cwd=unpacked_source_directory,
)
PK ! {3 3 install/__init__.pynu [ """For modules related to installing packages.
"""
PK ! X*k k install/wheel.pynu [ """Support for installing and building the "wheel" binary package format.
"""
import collections
import compileall
import contextlib
import csv
import importlib
import logging
import os.path
import re
import shutil
import sys
import warnings
from base64 import urlsafe_b64encode
from email.message import Message
from itertools import chain, filterfalse, starmap
from typing import (
IO,
TYPE_CHECKING,
Any,
BinaryIO,
Callable,
Dict,
Iterable,
Iterator,
List,
NewType,
Optional,
Sequence,
Set,
Tuple,
Union,
cast,
)
from zipfile import ZipFile, ZipInfo
from pip._vendor.distlib.scripts import ScriptMaker
from pip._vendor.distlib.util import get_export_entry
from pip._vendor.packaging.utils import canonicalize_name
from pip._internal.exceptions import InstallationError
from pip._internal.locations import get_major_minor_version
from pip._internal.metadata import (
BaseDistribution,
FilesystemWheel,
get_wheel_distribution,
)
from pip._internal.models.direct_url import DIRECT_URL_METADATA_NAME, DirectUrl
from pip._internal.models.scheme import SCHEME_KEYS, Scheme
from pip._internal.utils.filesystem import adjacent_tmp_file, replace
from pip._internal.utils.misc import captured_stdout, ensure_dir, hash_file, partition
from pip._internal.utils.unpacking import (
current_umask,
is_within_directory,
set_extracted_file_to_default_mode_plus_executable,
zip_item_is_executable,
)
from pip._internal.utils.wheel import parse_wheel
if TYPE_CHECKING:
from typing import Protocol
class File(Protocol):
src_record_path: "RecordPath"
dest_path: str
changed: bool
def save(self) -> None:
pass
logger = logging.getLogger(__name__)
RecordPath = NewType("RecordPath", str)
InstalledCSVRow = Tuple[RecordPath, str, Union[int, str]]
def rehash(path: str, blocksize: int = 1 << 20) -> Tuple[str, str]:
"""Return (encoded_digest, length) for path using hashlib.sha256()"""
h, length = hash_file(path, blocksize)
digest = "sha256=" + urlsafe_b64encode(h.digest()).decode("latin1").rstrip("=")
return (digest, str(length))
def csv_io_kwargs(mode: str) -> Dict[str, Any]:
"""Return keyword arguments to properly open a CSV file
in the given mode.
"""
return {"mode": mode, "newline": "", "encoding": "utf-8"}
def fix_script(path: str) -> bool:
"""Replace #!python with #!/path/to/python
Return True if file was changed.
"""
# XXX RECORD hashes will need to be updated
assert os.path.isfile(path)
with open(path, "rb") as script:
firstline = script.readline()
if not firstline.startswith(b"#!python"):
return False
exename = sys.executable.encode(sys.getfilesystemencoding())
firstline = b"#!" + exename + os.linesep.encode("ascii")
rest = script.read()
with open(path, "wb") as script:
script.write(firstline)
script.write(rest)
return True
def wheel_root_is_purelib(metadata: Message) -> bool:
return metadata.get("Root-Is-Purelib", "").lower() == "true"
def get_entrypoints(dist: BaseDistribution) -> Tuple[Dict[str, str], Dict[str, str]]:
console_scripts = {}
gui_scripts = {}
for entry_point in dist.iter_entry_points():
if entry_point.group == "console_scripts":
console_scripts[entry_point.name] = entry_point.value
elif entry_point.group == "gui_scripts":
gui_scripts[entry_point.name] = entry_point.value
return console_scripts, gui_scripts
def message_about_scripts_not_on_PATH(scripts: Sequence[str]) -> Optional[str]:
"""Determine if any scripts are not on PATH and format a warning.
Returns a warning message if one or more scripts are not on PATH,
otherwise None.
"""
if not scripts:
return None
# Group scripts by the path they were installed in
grouped_by_dir: Dict[str, Set[str]] = collections.defaultdict(set)
for destfile in scripts:
parent_dir = os.path.dirname(destfile)
script_name = os.path.basename(destfile)
grouped_by_dir[parent_dir].add(script_name)
# We don't want to warn for directories that are on PATH.
not_warn_dirs = [
os.path.normcase(i).rstrip(os.sep)
for i in os.environ.get("PATH", "").split(os.pathsep)
]
# If an executable sits with sys.executable, we don't warn for it.
# This covers the case of venv invocations without activating the venv.
not_warn_dirs.append(os.path.normcase(os.path.dirname(sys.executable)))
warn_for: Dict[str, Set[str]] = {
parent_dir: scripts
for parent_dir, scripts in grouped_by_dir.items()
if os.path.normcase(parent_dir) not in not_warn_dirs
}
if not warn_for:
return None
# Format a message
msg_lines = []
for parent_dir, dir_scripts in warn_for.items():
sorted_scripts: List[str] = sorted(dir_scripts)
if len(sorted_scripts) == 1:
start_text = "script {} is".format(sorted_scripts[0])
else:
start_text = "scripts {} are".format(
", ".join(sorted_scripts[:-1]) + " and " + sorted_scripts[-1]
)
msg_lines.append(
"The {} installed in '{}' which is not on PATH.".format(
start_text, parent_dir
)
)
last_line_fmt = (
"Consider adding {} to PATH or, if you prefer "
"to suppress this warning, use --no-warn-script-location."
)
if len(msg_lines) == 1:
msg_lines.append(last_line_fmt.format("this directory"))
else:
msg_lines.append(last_line_fmt.format("these directories"))
# Add a note if any directory starts with ~
warn_for_tilde = any(
i[0] == "~" for i in os.environ.get("PATH", "").split(os.pathsep) if i
)
if warn_for_tilde:
tilde_warning_msg = (
"NOTE: The current PATH contains path(s) starting with `~`, "
"which may not be expanded by all applications."
)
msg_lines.append(tilde_warning_msg)
# Returns the formatted multiline message
return "\n".join(msg_lines)
def _normalized_outrows(
outrows: Iterable[InstalledCSVRow],
) -> List[Tuple[str, str, str]]:
"""Normalize the given rows of a RECORD file.
Items in each row are converted into str. Rows are then sorted to make
the value more predictable for tests.
Each row is a 3-tuple (path, hash, size) and corresponds to a record of
a RECORD file (see PEP 376 and PEP 427 for details). For the rows
passed to this function, the size can be an integer as an int or string,
or the empty string.
"""
# Normally, there should only be one row per path, in which case the
# second and third elements don't come into play when sorting.
# However, in cases in the wild where a path might happen to occur twice,
# we don't want the sort operation to trigger an error (but still want
# determinism). Since the third element can be an int or string, we
# coerce each element to a string to avoid a TypeError in this case.
# For additional background, see--
# https://github.com/pypa/pip/issues/5868
return sorted(
(record_path, hash_, str(size)) for record_path, hash_, size in outrows
)
def _record_to_fs_path(record_path: RecordPath) -> str:
return record_path
def _fs_to_record_path(path: str, relative_to: Optional[str] = None) -> RecordPath:
if relative_to is not None:
# On Windows, do not handle relative paths if they belong to different
# logical disks
if (
os.path.splitdrive(path)[0].lower()
== os.path.splitdrive(relative_to)[0].lower()
):
path = os.path.relpath(path, relative_to)
path = path.replace(os.path.sep, "/")
return cast("RecordPath", path)
def get_csv_rows_for_installed(
old_csv_rows: List[List[str]],
installed: Dict[RecordPath, RecordPath],
changed: Set[RecordPath],
generated: List[str],
lib_dir: str,
) -> List[InstalledCSVRow]:
"""
:param installed: A map from archive RECORD path to installation RECORD
path.
"""
installed_rows: List[InstalledCSVRow] = []
for row in old_csv_rows:
if len(row) > 3:
logger.warning("RECORD line has more than three elements: %s", row)
old_record_path = cast("RecordPath", row[0])
new_record_path = installed.pop(old_record_path, old_record_path)
if new_record_path in changed:
digest, length = rehash(_record_to_fs_path(new_record_path))
else:
digest = row[1] if len(row) > 1 else ""
length = row[2] if len(row) > 2 else ""
installed_rows.append((new_record_path, digest, length))
for f in generated:
path = _fs_to_record_path(f, lib_dir)
digest, length = rehash(f)
installed_rows.append((path, digest, length))
for installed_record_path in installed.values():
installed_rows.append((installed_record_path, "", ""))
return installed_rows
def get_console_script_specs(console: Dict[str, str]) -> List[str]:
"""
Given the mapping from entrypoint name to callable, return the relevant
console script specs.
"""
# Don't mutate caller's version
console = console.copy()
scripts_to_generate = []
# Special case pip and setuptools to generate versioned wrappers
#
# The issue is that some projects (specifically, pip and setuptools) use
# code in setup.py to create "versioned" entry points - pip2.7 on Python
# 2.7, pip3.3 on Python 3.3, etc. But these entry points are baked into
# the wheel metadata at build time, and so if the wheel is installed with
# a *different* version of Python the entry points will be wrong. The
# correct fix for this is to enhance the metadata to be able to describe
# such versioned entry points, but that won't happen till Metadata 2.0 is
# available.
# In the meantime, projects using versioned entry points will either have
# incorrect versioned entry points, or they will not be able to distribute
# "universal" wheels (i.e., they will need a wheel per Python version).
#
# Because setuptools and pip are bundled with _ensurepip and virtualenv,
# we need to use universal wheels. So, as a stopgap until Metadata 2.0, we
# override the versioned entry points in the wheel and generate the
# correct ones. This code is purely a short-term measure until Metadata 2.0
# is available.
#
# To add the level of hack in this section of code, in order to support
# ensurepip this code will look for an ``ENSUREPIP_OPTIONS`` environment
# variable which will control which version scripts get installed.
#
# ENSUREPIP_OPTIONS=altinstall
# - Only pipX.Y and easy_install-X.Y will be generated and installed
# ENSUREPIP_OPTIONS=install
# - pipX.Y, pipX, easy_install-X.Y will be generated and installed. Note
# that this option is technically if ENSUREPIP_OPTIONS is set and is
# not altinstall
# DEFAULT
# - The default behavior is to install pip, pipX, pipX.Y, easy_install
# and easy_install-X.Y.
pip_script = console.pop("pip", None)
if pip_script:
if "ENSUREPIP_OPTIONS" not in os.environ:
scripts_to_generate.append("pip = " + pip_script)
if os.environ.get("ENSUREPIP_OPTIONS", "") != "altinstall":
scripts_to_generate.append(
"pip{} = {}".format(sys.version_info[0], pip_script)
)
scripts_to_generate.append(f"pip{get_major_minor_version()} = {pip_script}")
# Delete any other versioned pip entry points
pip_ep = [k for k in console if re.match(r"pip(\d(\.\d)?)?$", k)]
for k in pip_ep:
del console[k]
easy_install_script = console.pop("easy_install", None)
if easy_install_script:
if "ENSUREPIP_OPTIONS" not in os.environ:
scripts_to_generate.append("easy_install = " + easy_install_script)
scripts_to_generate.append(
"easy_install-{} = {}".format(
get_major_minor_version(), easy_install_script
)
)
# Delete any other versioned easy_install entry points
easy_install_ep = [
k for k in console if re.match(r"easy_install(-\d\.\d)?$", k)
]
for k in easy_install_ep:
del console[k]
# Generate the console entry points specified in the wheel
scripts_to_generate.extend(starmap("{} = {}".format, console.items()))
return scripts_to_generate
class ZipBackedFile:
def __init__(
self, src_record_path: RecordPath, dest_path: str, zip_file: ZipFile
) -> None:
self.src_record_path = src_record_path
self.dest_path = dest_path
self._zip_file = zip_file
self.changed = False
def _getinfo(self) -> ZipInfo:
return self._zip_file.getinfo(self.src_record_path)
def save(self) -> None:
# directory creation is lazy and after file filtering
# to ensure we don't install empty dirs; empty dirs can't be
# uninstalled.
parent_dir = os.path.dirname(self.dest_path)
ensure_dir(parent_dir)
# When we open the output file below, any existing file is truncated
# before we start writing the new contents. This is fine in most
# cases, but can cause a segfault if pip has loaded a shared
# object (e.g. from pyopenssl through its vendored urllib3)
# Since the shared object is mmap'd an attempt to call a
# symbol in it will then cause a segfault. Unlinking the file
# allows writing of new contents while allowing the process to
# continue to use the old copy.
if os.path.exists(self.dest_path):
os.unlink(self.dest_path)
zipinfo = self._getinfo()
with self._zip_file.open(zipinfo) as f:
with open(self.dest_path, "wb") as dest:
shutil.copyfileobj(f, dest)
if zip_item_is_executable(zipinfo):
set_extracted_file_to_default_mode_plus_executable(self.dest_path)
class ScriptFile:
def __init__(self, file: "File") -> None:
self._file = file
self.src_record_path = self._file.src_record_path
self.dest_path = self._file.dest_path
self.changed = False
def save(self) -> None:
self._file.save()
self.changed = fix_script(self.dest_path)
class MissingCallableSuffix(InstallationError):
def __init__(self, entry_point: str) -> None:
super().__init__(
"Invalid script entry point: {} - A callable "
"suffix is required. Cf https://packaging.python.org/"
"specifications/entry-points/#use-for-scripts for more "
"information.".format(entry_point)
)
def _raise_for_invalid_entrypoint(specification: str) -> None:
entry = get_export_entry(specification)
if entry is not None and entry.suffix is None:
raise MissingCallableSuffix(str(entry))
class PipScriptMaker(ScriptMaker):
def make(self, specification: str, options: Dict[str, Any] = None) -> List[str]:
_raise_for_invalid_entrypoint(specification)
return super().make(specification, options)
def _install_wheel(
name: str,
wheel_zip: ZipFile,
wheel_path: str,
scheme: Scheme,
pycompile: bool = True,
warn_script_location: bool = True,
direct_url: Optional[DirectUrl] = None,
requested: bool = False,
) -> None:
"""Install a wheel.
:param name: Name of the project to install
:param wheel_zip: open ZipFile for wheel being installed
:param scheme: Distutils scheme dictating the install directories
:param req_description: String used in place of the requirement, for
logging
:param pycompile: Whether to byte-compile installed Python files
:param warn_script_location: Whether to check that scripts are installed
into a directory on PATH
:raises UnsupportedWheel:
* when the directory holds an unpacked wheel with incompatible
Wheel-Version
* when the .dist-info dir does not match the wheel
"""
info_dir, metadata = parse_wheel(wheel_zip, name)
if wheel_root_is_purelib(metadata):
lib_dir = scheme.purelib
else:
lib_dir = scheme.platlib
# Record details of the files moved
# installed = files copied from the wheel to the destination
# changed = files changed while installing (scripts #! line typically)
# generated = files newly generated during the install (script wrappers)
installed: Dict[RecordPath, RecordPath] = {}
changed: Set[RecordPath] = set()
generated: List[str] = []
def record_installed(
srcfile: RecordPath, destfile: str, modified: bool = False
) -> None:
"""Map archive RECORD paths to installation RECORD paths."""
newpath = _fs_to_record_path(destfile, lib_dir)
installed[srcfile] = newpath
if modified:
changed.add(_fs_to_record_path(destfile))
def is_dir_path(path: RecordPath) -> bool:
return path.endswith("/")
def assert_no_path_traversal(dest_dir_path: str, target_path: str) -> None:
if not is_within_directory(dest_dir_path, target_path):
message = (
"The wheel {!r} has a file {!r} trying to install"
" outside the target directory {!r}"
)
raise InstallationError(
message.format(wheel_path, target_path, dest_dir_path)
)
def root_scheme_file_maker(
zip_file: ZipFile, dest: str
) -> Callable[[RecordPath], "File"]:
def make_root_scheme_file(record_path: RecordPath) -> "File":
normed_path = os.path.normpath(record_path)
dest_path = os.path.join(dest, normed_path)
assert_no_path_traversal(dest, dest_path)
return ZipBackedFile(record_path, dest_path, zip_file)
return make_root_scheme_file
def data_scheme_file_maker(
zip_file: ZipFile, scheme: Scheme
) -> Callable[[RecordPath], "File"]:
scheme_paths = {key: getattr(scheme, key) for key in SCHEME_KEYS}
def make_data_scheme_file(record_path: RecordPath) -> "File":
normed_path = os.path.normpath(record_path)
try:
_, scheme_key, dest_subpath = normed_path.split(os.path.sep, 2)
except ValueError:
message = (
"Unexpected file in {}: {!r}. .data directory contents"
" should be named like: '/'."
).format(wheel_path, record_path)
raise InstallationError(message)
try:
scheme_path = scheme_paths[scheme_key]
except KeyError:
valid_scheme_keys = ", ".join(sorted(scheme_paths))
message = (
"Unknown scheme key used in {}: {} (for file {!r}). .data"
" directory contents should be in subdirectories named"
" with a valid scheme key ({})"
).format(wheel_path, scheme_key, record_path, valid_scheme_keys)
raise InstallationError(message)
dest_path = os.path.join(scheme_path, dest_subpath)
assert_no_path_traversal(scheme_path, dest_path)
return ZipBackedFile(record_path, dest_path, zip_file)
return make_data_scheme_file
def is_data_scheme_path(path: RecordPath) -> bool:
return path.split("/", 1)[0].endswith(".data")
paths = cast(List[RecordPath], wheel_zip.namelist())
file_paths = filterfalse(is_dir_path, paths)
root_scheme_paths, data_scheme_paths = partition(is_data_scheme_path, file_paths)
make_root_scheme_file = root_scheme_file_maker(wheel_zip, lib_dir)
files: Iterator[File] = map(make_root_scheme_file, root_scheme_paths)
def is_script_scheme_path(path: RecordPath) -> bool:
parts = path.split("/", 2)
return len(parts) > 2 and parts[0].endswith(".data") and parts[1] == "scripts"
other_scheme_paths, script_scheme_paths = partition(
is_script_scheme_path, data_scheme_paths
)
make_data_scheme_file = data_scheme_file_maker(wheel_zip, scheme)
other_scheme_files = map(make_data_scheme_file, other_scheme_paths)
files = chain(files, other_scheme_files)
# Get the defined entry points
distribution = get_wheel_distribution(
FilesystemWheel(wheel_path),
canonicalize_name(name),
)
console, gui = get_entrypoints(distribution)
def is_entrypoint_wrapper(file: "File") -> bool:
# EP, EP.exe and EP-script.py are scripts generated for
# entry point EP by setuptools
path = file.dest_path
name = os.path.basename(path)
if name.lower().endswith(".exe"):
matchname = name[:-4]
elif name.lower().endswith("-script.py"):
matchname = name[:-10]
elif name.lower().endswith(".pya"):
matchname = name[:-4]
else:
matchname = name
# Ignore setuptools-generated scripts
return matchname in console or matchname in gui
script_scheme_files: Iterator[File] = map(
make_data_scheme_file, script_scheme_paths
)
script_scheme_files = filterfalse(is_entrypoint_wrapper, script_scheme_files)
script_scheme_files = map(ScriptFile, script_scheme_files)
files = chain(files, script_scheme_files)
for file in files:
file.save()
record_installed(file.src_record_path, file.dest_path, file.changed)
def pyc_source_file_paths() -> Iterator[str]:
# We de-duplicate installation paths, since there can be overlap (e.g.
# file in .data maps to same location as file in wheel root).
# Sorting installation paths makes it easier to reproduce and debug
# issues related to permissions on existing files.
for installed_path in sorted(set(installed.values())):
full_installed_path = os.path.join(lib_dir, installed_path)
if not os.path.isfile(full_installed_path):
continue
if not full_installed_path.endswith(".py"):
continue
yield full_installed_path
def pyc_output_path(path: str) -> str:
"""Return the path the pyc file would have been written to."""
return importlib.util.cache_from_source(path)
# Compile all of the pyc files for the installed files
if pycompile:
with captured_stdout() as stdout:
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
for path in pyc_source_file_paths():
success = compileall.compile_file(path, force=True, quiet=True)
if success:
pyc_path = pyc_output_path(path)
assert os.path.exists(pyc_path)
pyc_record_path = cast(
"RecordPath", pyc_path.replace(os.path.sep, "/")
)
record_installed(pyc_record_path, pyc_path)
logger.debug(stdout.getvalue())
maker = PipScriptMaker(None, scheme.scripts)
# Ensure old scripts are overwritten.
# See https://github.com/pypa/pip/issues/1800
maker.clobber = True
# Ensure we don't generate any variants for scripts because this is almost
# never what somebody wants.
# See https://bitbucket.org/pypa/distlib/issue/35/
maker.variants = {""}
# This is required because otherwise distlib creates scripts that are not
# executable.
# See https://bitbucket.org/pypa/distlib/issue/32/
maker.set_mode = True
# Generate the console and GUI entry points specified in the wheel
scripts_to_generate = get_console_script_specs(console)
gui_scripts_to_generate = list(starmap("{} = {}".format, gui.items()))
generated_console_scripts = maker.make_multiple(scripts_to_generate)
generated.extend(generated_console_scripts)
generated.extend(maker.make_multiple(gui_scripts_to_generate, {"gui": True}))
if warn_script_location:
msg = message_about_scripts_not_on_PATH(generated_console_scripts)
if msg is not None:
logger.warning(msg)
generated_file_mode = 0o666 & ~current_umask()
@contextlib.contextmanager
def _generate_file(path: str, **kwargs: Any) -> Iterator[BinaryIO]:
with adjacent_tmp_file(path, **kwargs) as f:
yield f
os.chmod(f.name, generated_file_mode)
replace(f.name, path)
dest_info_dir = os.path.join(lib_dir, info_dir)
# Record pip as the installer
installer_path = os.path.join(dest_info_dir, "INSTALLER")
with _generate_file(installer_path) as installer_file:
installer_file.write(b"pip\n")
generated.append(installer_path)
# Record the PEP 610 direct URL reference
if direct_url is not None:
direct_url_path = os.path.join(dest_info_dir, DIRECT_URL_METADATA_NAME)
with _generate_file(direct_url_path) as direct_url_file:
direct_url_file.write(direct_url.to_json().encode("utf-8"))
generated.append(direct_url_path)
# Record the REQUESTED file
if requested:
requested_path = os.path.join(dest_info_dir, "REQUESTED")
with open(requested_path, "wb"):
pass
generated.append(requested_path)
record_text = distribution.read_text("RECORD")
record_rows = list(csv.reader(record_text.splitlines()))
rows = get_csv_rows_for_installed(
record_rows,
installed=installed,
changed=changed,
generated=generated,
lib_dir=lib_dir,
)
# Record details of all files installed
record_path = os.path.join(dest_info_dir, "RECORD")
with _generate_file(record_path, **csv_io_kwargs("w")) as record_file:
# Explicitly cast to typing.IO[str] as a workaround for the mypy error:
# "writer" has incompatible type "BinaryIO"; expected "_Writer"
writer = csv.writer(cast("IO[str]", record_file))
writer.writerows(_normalized_outrows(rows))
@contextlib.contextmanager
def req_error_context(req_description: str) -> Iterator[None]:
try:
yield
except InstallationError as e:
message = "For req: {}. {}".format(req_description, e.args[0])
raise InstallationError(message) from e
def install_wheel(
name: str,
wheel_path: str,
scheme: Scheme,
req_description: str,
pycompile: bool = True,
warn_script_location: bool = True,
direct_url: Optional[DirectUrl] = None,
requested: bool = False,
) -> None:
with ZipFile(wheel_path, allowZip64=True) as z:
with req_error_context(req_description):
_install_wheel(
name=name,
wheel_zip=z,
wheel_path=wheel_path,
scheme=scheme,
pycompile=pycompile,
warn_script_location=warn_script_location,
direct_url=direct_url,
requested=requested,
)
PK ! G 1 build/__pycache__/metadata_legacy.cpython-310.pycnu [ o
ai @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ eeZd ed
efd d Zd
ededededed
ef ddZdS )z;Metadata generation logic for legacy source distributions.
N)BuildEnvironment) open_spinner)InstallationError) make_setuptools_egg_info_args)call_subprocess)
TempDirectory directoryreturnc C sR dd t | D }|std| t|dkr td| t j| |d S )z.Find an .egg-info subdirectory in `directory`.c S s g | ] }| d r|qS )z .egg-info)endswith).0f r
/builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/metadata_legacy.py
s z"_find_egg_info..z No .egg-info directory found in z-More than one .egg-info directory found in {}r )oslistdirr lenformatpathjoin)r filenamesr
r
r _find_egg_info s r build_env
setup_py_path
source_dirisolateddetailsc C s t d|| tdddj}t|||d}| 1 td}t||d|d W d n1 s/w Y W d t|S W d t|S 1 sKw Y t|S )
znGenerate metadata using setup.py-based defacto mechanisms.
Returns the generated metadata directory.
z2Running setup.py (path:%s) egg_info for package %sz pip-egg-infoT)kindglobally_managed) egg_info_dirno_user_configz Preparing metadata (setup.py)zpython setup.py egg_info)cwd command_descspinnerN)loggerdebugr r r r r r )r r r r r r argsr$ r
r
r generate_metadata s6
r( )__doc__loggingr pip._internal.build_envr pip._internal.cli.spinnersr pip._internal.exceptionsr $pip._internal.utils.setuptools_buildr pip._internal.utils.subprocessr pip._internal.utils.temp_dirr getLogger__name__r% strr boolr( r
r
r
r s0
PK ! I ' build/__pycache__/wheel.cpython-310.pycnu [ o
ai' @ sd d dl Z d dlZd dlmZ d dlmZ d dlmZ e e Z
de dede de d ee f
d
d Z dS ) N)Optional)Pep517HookCaller)runner_with_spinner_messagenamebackendmetadata_directorytempdreturnc C s |dusJ z,t d| td| d}|| |j||d}W d n1 s,w Y W n tyB t d| Y dS w tj ||S )zBuild one InstallRequirement using the PEP 517 build process.
Returns path to wheel if successfully built. Otherwise, returns None.
NzDestination directory: %szBuilding wheel for z (pyproject.toml))r z Failed building wheel for %s)
loggerdebugr subprocess_runner build_wheel Exceptionerrorospathjoin)r r r r runner
wheel_name r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/wheel.pybuild_wheel_pep517 s$
r )
loggingr typingr Zpip._vendor.pep517.wrappersr pip._internal.utils.subprocessr getLogger__name__r
strr r r r r s"
PK ! k<3 0 build/__pycache__/wheel_editable.cpython-310.pycnu [ o
ai} @ sh d dl Z d dlZd dlmZ d dlmZmZ d dlmZ e e
Z de dede de d ee f
d
d Z
dS ) N)Optional) HookMissingPep517HookCaller)runner_with_spinner_messagenamebackendmetadata_directorytempdreturnc C s |dusJ zPt d| td| d}||3 z |j||d}W n! tyE } zt d| | W Y d}~W d W dS d}~ww W d n1 sPw Y W n tyf t d| Y dS w tj
||S )zBuild one InstallRequirement using the PEP 660 build process.
Returns path to wheel if successfully built. Otherwise, returns None.
NzDestination directory: %szBuilding editable for z (pyproject.toml))r zLCannot build editable %s because the build backend does not have the %s hookz Failed building editable for %s) loggerdebugr subprocess_runnerbuild_editabler error Exceptionospathjoin)r r r r runner
wheel_namee r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/wheel_editable.pybuild_wheel_editable s<
r )loggingr typingr Zpip._vendor.pep517.wrappersr r pip._internal.utils.subprocessr getLogger__name__r strr r r r r s"
PK ! q_p2
. build/__pycache__/wheel_legacy.cpython-310.pycnu [ o
ai @ s d dl Z d dlZd dlmZmZ d dlmZ d dlm Z d dl
m Z m Z m
Z
e eZdee dedefd d
Zd ee d ed
edee dedee f ddZd
edededee dee dedee fddZdS ) N)ListOptional) open_spinner) make_setuptools_bdist_wheel_args) LOG_DIVIDERcall_subprocessformat_command_args command_argscommand_outputreturnc C sf t | }d| d}|s|d7 }|S t tjkr |d7 }|S |ds(|d7 }|d| t 7 }|S )z'Format command information for logging.zCommand arguments:
zCommand output: Nonez'Command output: [use --verbose to show]zCommand output:
)r loggergetEffectiveLevelloggingDEBUGendswithr )r r
command_desctext r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/wheel_legacy.pyformat_command_result s
r namestemp_dirnamec C st t | } | sd|}|t||7 }t| dS t| dkr1d|| }|t||7 }t| tj|| d S )z>Return the path to the wheel in the temporary build directory.z1Legacy build of wheel for {!r} created no files.
N zZLegacy build of wheel for {!r} created more than one file.
Filenames (choosing first): {}
r ) sortedformatr r
warninglenospathjoin)r r r r r
msgr r r get_legacy_build_wheel_path$ s
r#
setup_py_path
source_dirglobal_options
build_optionstempdc C s t ||||d}d| d}t|C}td| z t|||d} W n ty= |d td| Y W d dS w t |}
t
|
|| || d } | W d S 1 sXw Y dS )
zBuild one unpacked package using the "legacy" build process.
Returns path to wheel if successfully built. Otherwise, returns None.
)r& r' destination_dirzBuilding wheel for z (setup.py)zDestination directory: %s)cwdspinnererrorz Failed building wheel for %sN)r r r r r
) r r r
debugr Exceptionfinishr, r listdirr# ) r r$ r% r& r' r(
wheel_args spin_messager+ outputr
wheel_pathr r r build_wheel_legacy? s>
$r5 )r os.pathr typingr r pip._internal.cli.spinnersr $pip._internal.utils.setuptools_buildr pip._internal.utils.subprocessr r r getLogger__name__r
strr r# r5 r r r r sT
PK ! |` * build/__pycache__/metadata.cpython-310.pycnu [ o
ai_ @ sV d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z deded e
fd
d Z dS ) z4Metadata generation logic for source distributions.
N)Pep517HookCaller)BuildEnvironment)runner_with_spinner_message)
TempDirectory build_envbackendreturnc C s t ddd}|j}| & td}||
||}W d n1 s%w Y W d n1 s4w Y tj||S )zlGenerate metadata using mechanisms described in PEP 517.
Returns the generated metadata directory.
zmodern-metadataT)kindglobally_managedz#Preparing metadata (pyproject.toml)N)r pathr subprocess_runner prepare_metadata_for_build_wheelosjoin)r r metadata_tmpdir metadata_dirrunner distinfo_dir r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/metadata.pygenerate_metadata
s r ) __doc__r Zpip._vendor.pep517.wrappersr pip._internal.build_envr pip._internal.utils.subprocessr pip._internal.utils.temp_dirr strr r r r r s PK ! ں~ * build/__pycache__/__init__.cpython-310.pycnu [ o
ai @ s d S )N r r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/__init__.py s PK ! ~- 3 build/__pycache__/metadata_editable.cpython-310.pycnu [ o
ai @ sV d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z deded e
fd
d Z dS ) z4Metadata generation logic for source distributions.
N)Pep517HookCaller)BuildEnvironment)runner_with_spinner_message)
TempDirectory build_envbackendreturnc C s t ddd}|j}| & td}||
||}W d n1 s%w Y W d n1 s4w Y tj||S )zlGenerate metadata using mechanisms described in PEP 660.
Returns the generated metadata directory.
zmodern-metadataT)kindglobally_managedz,Preparing editable metadata (pyproject.toml)N)r pathr subprocess_runner#prepare_metadata_for_build_editableosjoin)r r metadata_tmpdir metadata_dirrunner distinfo_dir r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_internal/operations/build/metadata_editable.pygenerate_editable_metadata
s
r ) __doc__r Zpip._vendor.pep517.wrappersr pip._internal.build_envr pip._internal.utils.subprocessr pip._internal.utils.temp_dirr strr r r r r s PK ! Y0_ _ build/metadata.pynu [ """Metadata generation logic for source distributions.
"""
import os
from pip._vendor.pep517.wrappers import Pep517HookCaller
from pip._internal.build_env import BuildEnvironment
from pip._internal.utils.subprocess import runner_with_spinner_message
from pip._internal.utils.temp_dir import TempDirectory
def generate_metadata(build_env: BuildEnvironment, backend: 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 metadata (pyproject.toml)")
with backend.subprocess_runner(runner):
distinfo_dir = backend.prepare_metadata_for_build_wheel(metadata_dir)
return os.path.join(metadata_dir, distinfo_dir)
PK ! } } build/wheel_editable.pynu [ import logging
import os
from typing import Optional
from pip._vendor.pep517.wrappers import HookMissing, Pep517HookCaller
from pip._internal.utils.subprocess import runner_with_spinner_message
logger = logging.getLogger(__name__)
def build_wheel_editable(
name: str,
backend: Pep517HookCaller,
metadata_directory: str,
tempd: str,
) -> Optional[str]:
"""Build one InstallRequirement using the PEP 660 build process.
Returns path to wheel if successfully built. Otherwise, returns None.
"""
assert metadata_directory is not None
try:
logger.debug("Destination directory: %s", tempd)
runner = runner_with_spinner_message(
f"Building editable for {name} (pyproject.toml)"
)
with backend.subprocess_runner(runner):
try:
wheel_name = backend.build_editable(
tempd,
metadata_directory=metadata_directory,
)
except HookMissing as e:
logger.error(
"Cannot build editable %s because the build "
"backend does not have the %s hook",
name,
e,
)
return None
except Exception:
logger.error("Failed building editable for %s", name)
return None
return os.path.join(tempd, wheel_name)
PK ! ȇe build/wheel_legacy.pynu [ import logging
import os.path
from typing import List, Optional
from pip._internal.cli.spinners import open_spinner
from pip._internal.utils.setuptools_build import make_setuptools_bdist_wheel_args
from pip._internal.utils.subprocess import (
LOG_DIVIDER,
call_subprocess,
format_command_args,
)
logger = logging.getLogger(__name__)
def format_command_result(
command_args: List[str],
command_output: str,
) -> str:
"""Format command information for logging."""
command_desc = format_command_args(command_args)
text = f"Command arguments: {command_desc}\n"
if not command_output:
text += "Command output: None"
elif logger.getEffectiveLevel() > logging.DEBUG:
text += "Command output: [use --verbose to show]"
else:
if not command_output.endswith("\n"):
command_output += "\n"
text += f"Command output:\n{command_output}{LOG_DIVIDER}"
return text
def get_legacy_build_wheel_path(
names: List[str],
temp_dir: str,
name: str,
command_args: List[str],
command_output: str,
) -> Optional[str]:
"""Return the path to the wheel in the temporary build directory."""
# Sort for determinism.
names = sorted(names)
if not names:
msg = ("Legacy build of wheel for {!r} created no files.\n").format(name)
msg += format_command_result(command_args, command_output)
logger.warning(msg)
return None
if len(names) > 1:
msg = (
"Legacy build of wheel for {!r} created more than one file.\n"
"Filenames (choosing first): {}\n"
).format(name, names)
msg += format_command_result(command_args, command_output)
logger.warning(msg)
return os.path.join(temp_dir, names[0])
def build_wheel_legacy(
name: str,
setup_py_path: str,
source_dir: str,
global_options: List[str],
build_options: List[str],
tempd: str,
) -> Optional[str]:
"""Build one unpacked package using the "legacy" build process.
Returns path to wheel if successfully built. Otherwise, returns None.
"""
wheel_args = make_setuptools_bdist_wheel_args(
setup_py_path,
global_options=global_options,
build_options=build_options,
destination_dir=tempd,
)
spin_message = f"Building wheel for {name} (setup.py)"
with open_spinner(spin_message) as spinner:
logger.debug("Destination directory: %s", tempd)
try:
output = call_subprocess(
wheel_args,
cwd=source_dir,
spinner=spinner,
)
except Exception:
spinner.finish("error")
logger.error("Failed building wheel for %s", name)
return None
names = os.listdir(tempd)
wheel_path = get_legacy_build_wheel_path(
names=names,
temp_dir=tempd,
name=name,
command_args=wheel_args,
command_output=output,
)
return wheel_path
PK ! j build/metadata_editable.pynu [ """Metadata generation logic for source distributions.
"""
import os
from pip._vendor.pep517.wrappers import Pep517HookCaller
from pip._internal.build_env import BuildEnvironment
from pip._internal.utils.subprocess import runner_with_spinner_message
from pip._internal.utils.temp_dir import TempDirectory
def generate_editable_metadata(
build_env: BuildEnvironment, backend: Pep517HookCaller
) -> str:
"""Generate metadata using mechanisms described in PEP 660.
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/editable, so we don't have to
# consider the possibility that this hook doesn't exist.
runner = runner_with_spinner_message(
"Preparing editable metadata (pyproject.toml)"
)
with backend.subprocess_runner(runner):
distinfo_dir = backend.prepare_metadata_for_build_editable(metadata_dir)
return os.path.join(metadata_dir, distinfo_dir)
PK !
build/metadata_legacy.pynu [ """Metadata generation logic for legacy source distributions.
"""
import logging
import os
from pip._internal.build_env import BuildEnvironment
from pip._internal.cli.spinners import open_spinner
from pip._internal.exceptions import InstallationError
from pip._internal.utils.setuptools_build import make_setuptools_egg_info_args
from pip._internal.utils.subprocess import call_subprocess
from pip._internal.utils.temp_dir import TempDirectory
logger = logging.getLogger(__name__)
def _find_egg_info(directory: str) -> str:
"""Find an .egg-info subdirectory in `directory`."""
filenames = [f for f in os.listdir(directory) if f.endswith(".egg-info")]
if not filenames:
raise InstallationError(f"No .egg-info directory found in {directory}")
if len(filenames) > 1:
raise InstallationError(
"More than one .egg-info directory found in {}".format(directory)
)
return os.path.join(directory, filenames[0])
def generate_metadata(
build_env: BuildEnvironment,
setup_py_path: str,
source_dir: str,
isolated: bool,
details: str,
) -> str:
"""Generate metadata using setup.py-based defacto mechanisms.
Returns the generated metadata directory.
"""
logger.debug(
"Running setup.py (path:%s) egg_info for package %s",
setup_py_path,
details,
)
egg_info_dir = TempDirectory(kind="pip-egg-info", globally_managed=True).path
args = make_setuptools_egg_info_args(
setup_py_path,
egg_info_dir=egg_info_dir,
no_user_config=isolated,
)
with build_env:
with open_spinner("Preparing metadata (setup.py)") as spinner:
call_subprocess(
args,
cwd=source_dir,
command_desc="python setup.py egg_info",
spinner=spinner,
)
# Return the .egg-info directory.
return _find_egg_info(egg_info_dir)
PK ! build/__init__.pynu [ PK ! <F' ' build/wheel.pynu [ import logging
import os
from typing import Optional
from pip._vendor.pep517.wrappers import Pep517HookCaller
from pip._internal.utils.subprocess import runner_with_spinner_message
logger = logging.getLogger(__name__)
def build_wheel_pep517(
name: str,
backend: Pep517HookCaller,
metadata_directory: str,
tempd: str,
) -> Optional[str]:
"""Build one InstallRequirement using the PEP 517 build process.
Returns path to wheel if successfully built. Otherwise, returns None.
"""
assert metadata_directory is not None
try:
logger.debug("Destination directory: %s", tempd)
runner = runner_with_spinner_message(
f"Building wheel for {name} (pyproject.toml)"
)
with backend.subprocess_runner(runner):
wheel_name = backend.build_wheel(
tempd,
metadata_directory=metadata_directory,
)
except Exception:
logger.error("Failed building wheel for %s", name)
return None
return os.path.join(tempd, wheel_name)
PK ! __init__.pynu [ PK ! ľ
*& *& ; freeze.pynu [ PK ! kv & __init__.pyonu [ PK ! Ԟ+8s s
l' freeze.pyonu [ PK ! % 6 check.pycnu [ PK ! % q= check.pyonu [ PK ! ͯ D check.pynu [ PK ! Ԟ+8s s
X freeze.pycnu [ PK ! kv g __init__.pycnu [ PK ! )x x qh __pycache__/check.cpython-36.pycnu [ PK ! PH) ) ! 9n __pycache__/freeze.cpython-36.pycnu [ PK ! )x x & y __pycache__/check.cpython-36.opt-1.pycnu [ PK ! m-Wq q # __pycache__/__init__.cpython-36.pycnu [ PK ! m-Wq q ) E __pycache__/__init__.cpython-36.opt-1.pycnu [ PK ! PH) ) ' __pycache__/freeze.cpython-36.opt-1.pycnu [ PK ! ;'9 9 # __pycache__/prepare.cpython-310.pycnu [ PK ! 3S5^ ^ " __pycache__/freeze.cpython-310.pycnu [ PK ! # $ { __pycache__/__init__.cpython-310.pycnu [ PK ! S, ! __pycache__/check.cpython-310.pycnu [ PK ! :e ] ]
prepare.pynu [ PK ! > > =N install/legacy.pynu [ PK ! > * ^ install/__pycache__/legacy.cpython-310.pycnu [ PK ! nR R ) %m install/__pycache__/wheel.cpython-310.pycnu [ PK ! 3#
0 0 , install/__pycache__/__init__.cpython-310.pycnu [ PK ! we 3 install/__pycache__/editable_legacy.cpython-310.pycnu [ PK ! Z install/editable_legacy.pynu [ PK ! {3 3 b install/__init__.pynu [ PK ! X*k k install/wheel.pynu [ PK ! G 1 ,9 build/__pycache__/metadata_legacy.cpython-310.pycnu [ PK ! I ' \B build/__pycache__/wheel.cpython-310.pycnu [ PK ! k<3 0 G build/__pycache__/wheel_editable.cpython-310.pycnu [ PK ! q_p2
. M build/__pycache__/wheel_legacy.cpython-310.pycnu [ PK ! |` * Y build/__pycache__/metadata.cpython-310.pycnu [ PK ! ں~ * K^ build/__pycache__/__init__.cpython-310.pycnu [ PK ! ~- 3 _ build/__pycache__/metadata_editable.cpython-310.pycnu [ PK ! Y0_ _ e build/metadata.pynu [ PK ! } } i build/wheel_editable.pynu [ PK ! ȇe fo build/wheel_legacy.pynu [ PK ! j { build/metadata_editable.pynu [ PK !
u build/metadata_legacy.pynu [ PK ! V build/__init__.pynu [ PK ! <F' ' build/wheel.pynu [ PK * *