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 ! 1%m m ) __pycache__/package_finder.cpython-39.pycnu [ a
Re @ sZ d Z ddlZddlZddlZddlZddlmZmZmZm Z m
Z
m Z m Z ddl
mZ ddlmZ ddlmZ ddlmZ ddlmZ dd lmZmZmZmZ dd
l m Z m Z dd l m Z dd l!m"Z" dd
l#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;mZ> g dZ?e0e@ZAe e d e eBeCf f ZDe eBeBeBee eB eDf ZEd3e$e eBeBeBf eFeFd d d ZGG d!d" d"ZHee e4eCee d#d$d%ZIG d&d' d'ZJG d(d) d)ZKG d*d+ d+ZLG d,d- d-ZMeCeCeBd.d/d0ZNeCeCe eC d.d1d2ZOdS )4z!Routines related to PyPI, indexes N) FrozenSetIterableListOptionalSetTupleUnion)
specifiers)Tag)canonicalize_name) _BaseVersion)parse)BestVersionAlreadyInstalledDistributionNotFoundInvalidWheelFilenameUnsupportedWheel)
LinkCollector parse_links)InstallationCandidate)
FormatControl)Link) SearchScope)SelectionPreferences) TargetPython)Wheel)InstallRequirement) getLogger)WHEEL_EXTENSION)Hashes)
indent_log) build_netloc)check_requires_python)SUPPORTED_EXTENSIONS) url_to_path)r BestCandidateResult
PackageFinder F)link version_infoignore_requires_pythonreturnc C s| zt | j|d}W n$ tjy6 td| j| Y nB0 |sxdtt|}|sft d|| j| dS td|| j| dS )aa
Return whether the given Python version is compatible with a link's
"Requires-Python" value.
:param version_info: A 3-tuple of ints representing the Python
major-minor-micro version to check.
:param ignore_requires_python: Whether to ignore the "Requires-Python"
value if the given Python version isn't compatible.
)r( z2Ignoring invalid Requires-Python (%r) for link: %s.z4Link requires a different Python (%s not in: %r): %sFzBIgnoring failed Requires-Python check (%s not in: %r) for link: %sT)
r! requires_pythonr InvalidSpecifierloggerdebugjoinmapstrverbose)r' r( r)
is_compatibleversionr& r& /builddir/build/BUILDROOT/alt-python39-pip-21.3.1-2.el8.x86_64/opt/alt/python39/lib/python3.9/site-packages/pip/_internal/index/package_finder.py_check_link_requires_python3 s8
r7 c @ sZ e Zd ZdZedZd
eeee e e
e e
ddddZ e
ee
e e f ddd ZdS )
LinkEvaluatorzD
Responsible for evaluating links for a particular project.
z-py([123]\.?[0-9]?)$N) project_namecanonical_nameformats
target_python allow_yankedr) r* c C s4 |du r d}|| _ || _|| _|| _|| _|| _dS )a
:param project_name: The user supplied package name.
:param canonical_name: The canonical package name.
:param formats: The formats allowed for this package. Should be a set
with 'binary' or 'source' or both in it.
:param target_python: The target Python interpreter to use when
evaluating link compatibility. This is used, for example, to
check wheel compatibility, as well as when checking the Python
version, e.g. the Python version embedded in a link filename
(or egg fragment) and against an HTML link's optional PEP 503
"data-requires-python" attribute.
:param allow_yanked: Whether files marked as yanked (in the sense
of PEP 592) are permitted to be candidates for install.
:param ignore_requires_python: Whether to ignore incompatible
PEP 503 "data-requires-python" values in HTML links. Defaults
to False.
NF)
_allow_yanked_canonical_name_ignore_requires_python_formats_target_pythonr9 )selfr9 r: r; r< r= r) r& r& r6 __init__n s zLinkEvaluator.__init__)r' r* c C s d}|j r(| js(|jpd}dd| fS |jr<|j}|j}n| \}}|sPdS |tvrfdd| fS d| jvr|tkrd | j
}d|fS d |j v r|d
krd S |tkr0zt |j
}W n ty Y d S 0 t|j| jkrd
| j
}d|fS | j }||s*| }d d|}d|fS |j}d| jvrZ|tkrZd| j
}d|fS |slt|| j}|sd| j
}d|fS | j|} | r|d| }| d}
|
| jj krdS t || jj | j d} | sdS t!"d|| d|fS )aG
Determine whether a link is a candidate for installation.
:return: A tuple (is_candidate, result), where `result` is (1) a
version string if `is_candidate` is True, and (2) if
`is_candidate` is False, an optional string to log the reason
the link fails to qualify.
Nz Fzyanked for reason: )Fz
not a filez unsupported archive format: binaryz No binaries permitted for {}macosx10z.zip)Fz macosx10 one)Fzinvalid wheel filenamezwrong project name (not {})z^none of the wheel's tags ({}) are compatible (run pip debug --verbose to show compatible tags), sourcezNo sources permitted for z Missing project version for )FzPython version is incorrect)r( r) )FNzFound link %s, version: %sT)# is_yankedr>
yanked_reason egg_fragmentextsplitextr" rA r formatr9 pathr filenamer r namer? rB get_tags supportedget_formatted_file_tagsr0 r5 _extract_version_from_fragment_py_version_researchstartgroup
py_versionr7 py_version_infor@ r. r/ ) rC r' r5 reasonegg_inforM wheelsupported_tags file_tagsmatchr[ supports_pythonr& r& r6
evaluate_link sx
zLinkEvaluator.evaluate_link)N)__name__
__module__ __qualname____doc__recompilerW r2 r r boolr rD r r rd r& r& r& r6 r8 b s
%r8 )
candidateshashesr9 r* c
C s |s t dt| | t| S g }g }d}| D ]>}|j}|js@n"|j|drV|d7 }n || q.|| q.|rx|}nt| }t|t| krd} n dt|d dd |D } t d
t| ||j
|t|| | |S ) a
Filter out candidates whose hashes aren't allowed, and return a new
list of candidates.
If at least one candidate has an allowed hash, then all candidates with
either an allowed hash or no hash specified are returned. Otherwise,
the given candidates are returned.
Including the candidates with no hash specified when there is a match
allows a warning to be logged if there is a more preferred candidate
with no hash specified. Returning all candidates in the case of no
matches lets pip report the hash of the candidate that would otherwise
have been installed (e.g. permitting the user to more easily update
their requirements file with the desired hash).
zJGiven no hashes to check %s links for project %r: discarding no candidatesr )rm rI zdiscarding no candidatesz discarding {} non-matches:
{}z
c s s | ]}t |jV qd S N)r2 r' ).0 candidater& r& r6 $ z*filter_unallowed_hashes..zPChecked %s links for project %r against %s hashes (%s matches, %s no digest): %s) r. r/ lenlistr' has_hashis_hash_allowedappendrO r0 digest_count)
rl rm r9 matches_or_no_digest non_matches match_countrp r' filtereddiscard_messager& r& r6 filter_unallowed_hashes sL
r~ c @ s$ e Zd ZdZdeeddddZdS )CandidatePreferenceszk
Encapsulates some of the preferences for filtering and sorting
InstallationCandidate objects.
FN)
prefer_binaryallow_all_prereleasesr* c C s || _ || _dS )zR
:param allow_all_prereleases: Whether to allow all pre-releases.
N)r r )rC r r r& r& r6 rD < s z CandidatePreferences.__init__)FF)re rf rg rh rk rD r& r& r& r6 r 5 s r c @ sT e Zd ZdZee ee ee ddddZee dddZ ee dd d
Z
dS ) r$ zA collection of candidates, returned by `PackageFinder.find_best_candidate`.
This class is only intended to be instantiated by CandidateEvaluator's
`compute_best_candidate()` method.
N)rl applicable_candidatesbest_candidater* c C sH t |t |ksJ |du r&|r2J n ||v s2J || _|| _|| _dS )a
:param candidates: A sequence of all available candidates found.
:param applicable_candidates: The applicable candidates.
:param best_candidate: The most preferred candidate found, or None
if no applicable candidates were found.
N)set_applicable_candidates _candidatesr rC rl r r r& r& r6 rD O s
z BestCandidateResult.__init__r* c C s
t | jS )z Iterate through all candidates.)iterr rC r& r& r6 iter_allg s z BestCandidateResult.iter_allc C s
t | jS )z*Iterate through the applicable candidates.)r r r r& r& r6 iter_applicablek s z#BestCandidateResult.iter_applicable) re rf rg rh r r r rD r r r r& r& r& r6 r$ H s r$ c
@ s e Zd ZdZedeee eeee j
ee d dddZ dee
e e j
eeee dddd Ze
e e
e d
d d Zeed
ddZe
e ee d
ddZe
e ed
ddZdS )CandidateEvaluatorzm
Responsible for filtering and sorting candidates for installation based
on what tags are valid.
NF)r9 r< r r specifierrm r* c C s: |du rt }|du r t }| }| ||||||dS )a Create a CandidateEvaluator object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:param hashes: An optional collection of allowed hashes.
N)r9 r` r r r rm )r r SpecifierSetrS )clsr9 r< r r r rm r` r& r& r6 createw s zCandidateEvaluator.create)r9 r` r r r rm r* c C s< || _ || _|| _|| _|| _|| _dd t|D | _dS )z
:param supported_tags: The PEP 425 tags supported by the target
Python in order of preference (most preferred first).
c S s i | ]\}}||qS r& r& )ro idxtagr& r& r6
s z/CandidateEvaluator.__init__..N)_allow_all_prereleases_hashes_prefer_binary
_project_name
_specifier_supported_tags enumerate_wheel_tag_preferences)rC r9 r` r r r rm r& r& r6 rD s
zCandidateEvaluator.__init__)rl r* c sd | j pd}| j}dd |jdd |D |dD fdd|D }t|| j| jd }t|| jd
S ) zM
Return the applicable candidates from a list of candidates.
Nc S s h | ] }t |qS r& )r2 )ro vr& r& r6 s z?CandidateEvaluator.get_applicable_candidates..c s s | ]}t |jV qd S rn r2 r5 ro cr& r& r6 rq rr z?CandidateEvaluator.get_applicable_candidates..) prereleasesc s g | ]}t |j v r|qS r& r r versionsr& r6
rr z@CandidateEvaluator.get_applicable_candidates..)rl rm r9 key)r r filterr~ r r sorted _sort_key)rC rl allow_prereleasesr r filtered_applicable_candidatesr& r r6 get_applicable_candidates s
z,CandidateEvaluator.get_applicable_candidates)rp r* c
C s | j }t|}d}d}|j}|jrt|j}z||| j }W n" tyb t d
|jY n0 | j rnd}|j durt
d|j } | }
t|
d |
d f}n| }t|| j} dt|j } | | ||j||fS )a)
Function to pass as the `key` argument to a call to sorted() to sort
InstallationCandidates by preference.
Returns a tuple such that tuples sorting as greater using Python's
default comparison operator are more preferred.
The preference is as follows:
First and foremost, candidates with allowed (matching) hashes are
always preferred over candidates without matching hashes. This is
because e.g. if the only candidate with an allowed hash is yanked,
we still want to use that candidate.
Second, excepting hash considerations, candidates that have been
yanked (in the sense of PEP 592) are always less preferred than
candidates that haven't been yanked. Then:
If not finding wheels, they are sorted by version only.
If finding wheels, then the sort order is by version, then:
1. existing installs
2. wheels ordered via Wheel.support_index_min(self._supported_tags)
3. source archives
If prefer_binary was set, then all wheels are sorted above sources.
Note: it was considered to embed this logic into the Link
comparison operators, but then different sdist links
with the same version, would have to be considered equal
r& r zB{} is not a supported wheel for this platform. It can't be sorted.rI Nz ^(\d+)(.*)$)r rs r' is_wheelr rQ find_most_preferred_tagr
ValueErrorr rO r build_tagri rb groupsintrv r rJ r5 )
rC rp
valid_tags support_numr binary_preferencer' r_ prirb build_tag_groupshas_allowed_hash
yank_valuer& r& r6 r sD
z CandidateEvaluator._sort_keyc C s |sdS t || jd}|S )zy
Return the best candidate per the instance's sort order, or None if
no candidate is acceptable.
Nr )maxr )rC rl r r& r& r6 sort_best_candidate s z&CandidateEvaluator.sort_best_candidatec C s" | |}| |}t|||dS )zF
Compute and return a `BestCandidateResult` instance.
)r r )r r r$ r r& r& r6 compute_best_candidate* s
z)CandidateEvaluator.compute_best_candidate)NFFNN)FFN)re rf rg rh classmethodr2 r r rk r
BaseSpecifierr r r r
rD r r CandidateSortingKeyr r r$ r r& r& r& r6 r p sL ( $F r c @ s e Zd ZdZd;eeeee ee ee ddddZ
e deee)j* ee+ e.d3d6d7Z/e0eee" d8d9d:Z1dS )?r% zThis finds packages.
This is meant to match easy_install's technique for looking for
packages, by reading pages and looking for appropriate links.
N)link_collectorr< r= format_controlcandidate_prefsr) r* c C sP |du rt }|p tt t }|| _|| _|| _|| _|| _|| _t | _ dS )a
This constructor is primarily meant to be used by the create() class
method and from tests.
:param format_control: A FormatControl object, used to control
the selection of source packages / binary packages when consulting
the index and links.
:param candidate_prefs: Options to use when creating a
CandidateEvaluator object.
N)
r r r r> _candidate_prefsr@ _link_collectorrB r
_logged_links)rC r r< r= r r r) r& r& r6 rD C s zPackageFinder.__init__)r selection_prefsr< r* c C s8 |du rt }t|j|jd}| ||||j|j|jdS )af Create a PackageFinder.
:param selection_prefs: The candidate selection preferences, as a
SelectionPreferences object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
N)r r )r r r< r= r r) )r r r r r= r r) )r r r r< r r& r& r6 r j s zPackageFinder.creater c C s | j S rn )rB r r& r& r6 r< s zPackageFinder.target_pythonc C s | j jS rn r search_scoper r& r& r6 r s zPackageFinder.search_scope)r r* c C s || j _d S rn r )rC r r& r& r6 r s c C s | j jS rn )r
find_linksr r& r& r6 r s zPackageFinder.find_linksc C s | j jS rn )r
index_urlsr r& r& r6 r s zPackageFinder.index_urlsc c s | j jjD ]}t| V q
d S rn )r sessionpip_trusted_originsr )rC host_portr& r& r6
trusted_hosts s zPackageFinder.trusted_hostsc C s | j jS rn r r r r& r& r6 r s z#PackageFinder.allow_all_prereleasesc C s d| j _d S NTr r r& r& r6 set_allow_all_prereleases s z'PackageFinder.set_allow_all_prereleasesc C s | j jS rn r r r r& r& r6 r s zPackageFinder.prefer_binaryc C s d| j _d S r r r r& r& r6 set_prefer_binary s z PackageFinder.set_prefer_binary)r9 r* c C s. t |}| j|}t|||| j| j| jdS )N)r9 r: r; r< r= r) )r r get_allowed_formatsr8 rB r> r@ )rC r9 r: r; r& r& r6 make_link_evaluator s z!PackageFinder.make_link_evaluator)linksr* c C sP g g }}t }|D ]2}||vr|| |jr<|| q|| q|| S )z
Returns elements of links in order, non-egg links first, egg links
second, while eliminating duplicates
)r addrL rw )rC r eggsno_eggsseenr' r& r& r6 _sort_links s
zPackageFinder._sort_links)r' r] r* c C s( || j vr$td|| | j | d S )NzSkipping link: %s: %s)r r. r/ r )rC r' r] r& r& r6 _log_skipped_link s
z PackageFinder._log_skipped_link)link_evaluatorr' r* c C s8 | |\}}|s(|r$| j||d dS t|j||dS )z
If the link is a candidate for install, convert it to an
InstallationCandidate and return it. Otherwise, return None.
)r] N)rR r' r5 )rd r r r9 )rC r r' is_candidateresultr& r& r6 get_install_candidate s z#PackageFinder.get_install_candidate)r r r* c C s6 g }| |D ]"}| ||}|dur|| q|S )zU
Convert links that are candidates to InstallationCandidate objects.
N)r r rw )rC r r rl r' rp r& r& r6 evaluate_links s z PackageFinder.evaluate_links) project_urlr r* c C sh t d| | j|}|d u r$g S tt|}t | j||d}W d n1 sZ0 Y |S )Nz-Fetching project page and analyzing links: %s)r )r. r/ r
fetch_pagert r r r )rC r r html_page
page_links
package_linksr& r& r6 process_project_url s $z!PackageFinder.process_project_url)maxsizec C s | |}| jj|tj| j|dd}tjdd |D }t |}tjdd |D }|
|t |dd}t
tjr|rdd |D }t d
d | || S ) a Find all available InstallationCandidate for project_name
This checks index_urls and find_links.
All versions found are returned as an InstallationCandidate list.
See LinkEvaluator.evaluate_link() for details on which files
are accepted.
)r )r9 candidates_from_pagec s s( | ] }|D ]}|d ur
| V q
qd S rn )page_candidatesro sourcesrH r& r& r6 rq s z4PackageFinder.find_all_candidates..c s s( | ] }|D ]}|d ur
| V q
qd S rn )
file_linksr r& r& r6 rq ' s T)reversec S s g | ]}t |jjqS r& )r# r' urlr r& r& r6 r 3 rr z5PackageFinder.find_all_candidates..zLocal files found: %srG )r r collect_sources functoolspartialr itertoolschain
from_iterablert r r r. isEnabledForloggingDEBUGr/ r0 ) rC r9 r collected_sourcespage_candidates_itr
file_links_itfile_candidatespathsr& r& r6 find_all_candidates s.
z!PackageFinder.find_all_candidates)r9 r rm r* c C s" | j }tj|| j|j|j||dS )z*Create a CandidateEvaluator object to use.)r9 r< r r r rm )r r r rB r r )rC r9 r rm r r& r& r6 make_candidate_evaluator9 s z&PackageFinder.make_candidate_evaluatorc C s$ | |}| j|||d}||S )a Find matches for the given project and specifier.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:return: A `BestCandidateResult` instance.
)r9 r rm )r r r )rC r9 r rm rl candidate_evaluatorr& r& r6 find_best_candidateJ s
z!PackageFinder.find_best_candidate)requpgrader* c C s |j dd}| j|j|j|d}|j}d}|jdur@t|jj}tt t
ddd}|du r|du rt d|||
td |d}|r|du s|j|krd
}|s|dur|rt d | nt d ||j dS |rt d
||| tt d|j|| |S )zTry to find a Link matching req
Expects req, an InstallRequirement and upgrade, a boolean
Returns a InstallationCandidate if found,
Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
F)trust_internet)r rm N) cand_iterr* c S s d tdd | D tdp dS )NrG c S s h | ]}t |jqS r& r r r& r& r6 r ~ rr zKPackageFinder.find_requirement.._format_versions..r none)r0 r
parse_version)r r& r& r6 _format_versionsv s z8PackageFinder.find_requirement.._format_versionszNCould not find a version that satisfies the requirement %s (from versions: %s)z%No matching distribution found for {}TzLExisting installed version (%s) is most up-to-date and satisfies requirementzUExisting installed version (%s) satisfies requirement (most up-to-date version is %s)z=Installed version (%s) is most up-to-date (past versions: %s)z)Using version %s (newest of versions: %s))rm r rR r r satisfied_byr r5 r r r2 r. criticalr r rO r/ r r ) rC r r rm best_candidate_resultr installed_versionr
best_installedr& r& r6 find_requirementa sh
z PackageFinder.find_requirement)NNN)N)NN)NN)2re rf rg rh r r rk r r r rD r r r propertyr< r r setterr r2 r r r r r r r r r8 r r r r r r r r r lru_cacher r r r r r r$ r r r r& r& r& r6 r% < s '
0
r% )fragmentr: r* c C sN t | D ].\}}|dkrqt| d| |kr| S qt| d| dS )a Find the separator's index based on the package's canonical name.
:param fragment: A + filename "fragment" (stem) or
egg fragment.
:param canonical_name: The package's canonical name.
This function is needed since the canonicalized name does not necessarily
have the same length as the egg info's name part. An example::
>>> fragment = 'foo__bar-1.0'
>>> canonical_name = 'foo-bar'
>>> _find_name_version_sep(fragment, canonical_name)
8
-Nz does not match )r r r )r r: ir r& r& r6 _find_name_version_sep s
r c C s@ zt | |d }W n ty& Y dS 0 | |d }|s+ filename
"fragment" (stem) or egg fragment.
:param fragment: The string to parse. E.g. foo-2.1
:param canonical_name: The canonicalized name of the package this
belongs to.
rI N)r r )r r:
version_startr5 r& r& r6 rV s rV )F)Prh r r r ri typingr r r r r r r Zpip._vendor.packagingr Zpip._vendor.packaging.tagsr
pip._vendor.packaging.utilsr Z pip._vendor.packaging.versionr r
r pip._internal.exceptionsr r r r pip._internal.index.collectorr r pip._internal.models.candidater #pip._internal.models.format_controlr pip._internal.models.linkr !pip._internal.models.search_scoper $pip._internal.models.selection_prefsr "pip._internal.models.target_pythonr pip._internal.models.wheelr pip._internal.reqr Zpip._internal.utils._logr pip._internal.utils.filetypesr pip._internal.utils.hashesr pip._internal.utils.loggingr pip._internal.utils.miscr pip._internal.utils.packagingr! pip._internal.utils.unpackingr" pip._internal.utils.urlsr# __all__re r. r r2 BuildTagr rk r7 r8 r~ r r$ r r% r rV r& r& r& r6 sn $ / J( M ~PK ! >k> > " __pycache__/sources.cpython-39.pycnu [ a
Re @ s0 d dl Z d dlZd dlZd dlZd dlmZmZmZmZ d dl m
Z
d dl m Z d dl
mZmZ d dlmZ e eZee
Zee Zee gee
f Zee gef ZG dd dZeed d
d Z G d d
d
eZ G dd deZ G dd deZ G dd deZ eeeeeeee ee f dddZ!dS ) N)CallableIterableOptionalTuple)InstallationCandidate)Link) path_to_url url_to_path)is_urlc @ s> e Zd Zeee dddZedddZe dddZ
dS )
LinkSourcereturnc C s
t dS )z,Returns the underlying link, if there's one.NNotImplementedErrorself r /builddir/build/BUILDROOT/alt-python39-pip-21.3.1-2.el8.x86_64/opt/alt/python39/lib/python3.9/site-packages/pip/_internal/index/sources.pylink s zLinkSource.linkc C s
t dS )z9Candidates found by parsing an archive listing HTML file.Nr r r r r page_candidates s zLinkSource.page_candidatesc C s
t dS )z,Links found by specifying archives directly.Nr r r r r
file_links s zLinkSource.file_linksN) __name__
__module__ __qualname__propertyr r r FoundCandidatesr
FoundLinksr r r r r r s r )file_urlr
c C s t j| ddd dkS )NF)strictr z text/html) mimetypes
guess_type)r r r r
_is_html_file# s r! c @ sT e Zd ZdZeeddddZeee dddZ
e dd d
Z e
dd d ZdS )
_FlatDirectorySourcezLink source specified by ``--find-links=``.
This looks the content of the directory, and returns:
* ``page_candidates``: Links listed on each HTML file in the directory.
* ``file_candidates``: Archives in the directory.
N)candidates_from_pagepathr
c C s || _ ttj|| _d S N)_candidates_from_pagepathlibPathosr$ realpath_path)r r# r$ r r r __init__0 s z _FlatDirectorySource.__init__r c C s d S r% r r r r r r 8 s z_FlatDirectorySource.linkc c s> | j D ].}tt|}t|s$q
| t|E d H q
d S r% )r+ iterdirr strr! r& r r r$ urlr r r r < s
z$_FlatDirectorySource.page_candidatesc c s4 | j D ]$}tt|}t|r$q
t|V q
d S r% )r+ r- r r. r! r r/ r r r r C s
z _FlatDirectorySource.file_links)r r r __doc__CandidatesFromPager. r, r r r r r r r r r r r r r" ' s
r" c @ sT e Zd ZdZeeddddZeee dddZ e
dd d
Z e dd d Z
dS )
_LocalFileSourceaC ``--find-links=`` or ``--[extra-]index-url=``.
If a URL is supplied, it must be a ``file:`` URL. If a path is supplied to
the option, it is converted to a URL first. This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
Nr# r r
c C s || _ || _d S r% r& _linkr r# r r r r r, U s z_LocalFileSource.__init__r c C s | j S r% r6 r r r r r ] s z_LocalFileSource.linkc c s& t | jjsd S | | jE d H d S r% )r! r6 r0 r& r r r r r a s z _LocalFileSource.page_candidatesc c s t | jjrd S | jV d S r% )r! r6 r0 r r r r r f s z_LocalFileSource.file_linksr r r r1 r2 r r, r r r r r r r r r r r r3 K s r3 c @ sV e Zd ZdZeeeddddZee e dddZ
e dd d
Z e
dd d ZdS )
_RemoteFileSourcez``--find-links=`` or ``--[extra-]index-url=``.
This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
N)r# page_validatorr r
c C s || _ || _|| _d S r% )r& _page_validatorr6 )r r# r; r r r r r, u s z_RemoteFileSource.__init__r c C s | j S r% r8 r r r r r s z_RemoteFileSource.linkc c s& | | jsd S | | jE d H d S r% )r< r6 r& r r r r r s z!_RemoteFileSource.page_candidatesc c s | j V d S r% r8 r r r r r s z _RemoteFileSource.file_links)r r r r1 r2
PageValidatorr r, r r r r r r r r r r r r: l s
r: c @ sT e Zd ZdZeeddddZeee dddZ e
dd d
Z e dd d Z
dS )
_IndexDirectorySourcez``--[extra-]index-url=``.
This is treated like a remote URL; ``candidates_from_page`` contains logic
for this by appending ``index.html`` to the link.
Nr4 c C s || _ || _d S r% r5 r7 r r r r, s z _IndexDirectorySource.__init__r c C s | j S r% r8 r r r r r s z_IndexDirectorySource.linkc c s | | jE d H d S r% r5 r r r r r s z%_IndexDirectorySource.page_candidatesc C s dS )Nr r r r r r r s z _IndexDirectorySource.file_linksr9 r r r r r> s r> )locationr# r;
expand_dircache_link_parsingr
c C s d }d }t j| r"t| }| }n$| dr:| }t| }n t| rF| }|d u rbd}t|| dS |d u rt ||t
||dd}||fS t j |r|rt ||d}nt
|t
||dd}||fS t j|rt|t
||dd}||fS td| |d fS ) Nzfile:zVLocation '%s' is ignored: it is either a non-existing path or lacks a specific scheme.)NN)rA )r# r; r )r# r$ )r# r z?Location '%s' is ignored: it is neither a file nor a directory.)r) r$ existsr
startswithr r
loggerwarningr: r isdirr" r> isfiler3 ) r? r# r; r@ rA r$ r0 msgsourcer r r build_source sX
rJ )"loggingr r) r' typingr r r r pip._internal.models.candidater pip._internal.models.linkr pip._internal.utils.urlsr r pip._internal.vcsr
getLoggerr rD r r r2 boolr= r r. r! r" r3 r: r> rJ r r r r s4
$! PK ! Srl # __pycache__/__init__.cpython-39.pycnu [ a
Re @ s d Z dS )zIndex interaction code
N)__doc__ r r /builddir/build/BUILDROOT/alt-python39-pip-21.3.1-2.el8.x86_64/opt/alt/python39/lib/python3.9/site-packages/pip/_internal/index/__init__.py PK ! /> /> $ __pycache__/collector.cpython-39.pycnu [ a
Re~D @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZ ddl
Z ddl Z ddl
mZ ddlmZmZmZmZmZmZmZmZ ddlmZmZ ddlm Z ddl m Z m Z ddl m!Z! dd l"m#Z# dd
l$m%Z% dd l&m'Z' dd l(m)Z) dd
l*m+Z+ ddl,m-Z-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3m4Z4 e5e6Z7e j8j9j:Z;eeG dd de?Z@e ddddZAG dd de?ZBed7 d7ZSdNe#ee L s r> )r sessionr c C sF t j| \}}}}}|dvr$t |j| dd}t| t| dS )zSend a HEAD request to the URL, and ensure the response contains HTML.
Raises `_NotHTTP` if the URL is not available for a HEAD request, or
`_NotHTML` if the content type is not text/html.
> httphttpsT)allow_redirectsN)urllibparseurlsplitr> headr r= )r r? r# netlocpathqueryfragmentrespr$ r$ r% _ensure_html_responseP s rL c C sR t t| jrt| |d tdt| |j| dddd}t| t | |S )a Access an HTML page with GET, and return the response.
This consists of three parts:
1. If the URL looks suspiciously like an archive, send a HEAD first to
check the Content-Type is HTML, to avoid downloading a large file.
Raise `_NotHTTP` if the content type cannot be determined, or
`_NotHTML` if it is not HTML.
2. Actually perform the request. Raise HTTP exceptions on network failures.
3. Check the Content-Type header to make sure we got HTML, and raise
`_NotHTML` otherwise.
r? zGetting page %sr8 z max-age=0)Acceptz
Cache-Control)r9 )
r r filenamerL loggerdebugr r: r r= )r r? rK r$ r$ r% _get_html_response` s
rR )r9 r c C s2 | r.d| v r.t | d \}}d|v r.|d S dS )z=Determine if we have any encoding information in our headers.r6 charsetN)cgi parse_header)r9 r( paramsr$ r$ r% _get_encoding_from_headers s
rW )documentpage_urlr c C s. | dD ] }|d}|dur
| S q
|S )a Determine the HTML document's base URL.
This looks for a ```` tag in the HTML document. If present, its href
attribute denotes the base URL of anchor tags in the document. If there is
no such tag (or if it does not have a valid href attribute), the HTML
file's URL is used as the base URL.
:param document: An HTML document representation. The current
implementation expects the result of ``html5lib.parse()``.
:param page_url: The URL of the HTML document.
z.//basehrefN)findallr: )rX rY baserZ r$ r$ r% _determine_base_url s
r] )partr c C s t jt j| S )zP
Clean a "part" of a URL path (i.e. after splitting on "@" characters).
)rC rD quoteunquoter^ r$ r$ r% _clean_url_path_part s rb c C s t jt j| S )z
Clean the first part of a URL path that corresponds to a local
filesystem path (i.e. the first part after splitting on "@" characters).
)rC r; pathname2url url2pathnamera r$ r$ r% _clean_file_url_path s
re z(@|%2F))rH
is_local_pathr c C s^ |r
t }nt}t| }g }tt|dgD ]$\}}||| || q.d |S )z*
Clean the path portion of a URL.
r7 )
re rb _reserved_chars_resplitr itertoolschainappendupperjoin)rH rf
clean_funcparts
cleaned_partsto_cleanreservedr$ r$ r% _clean_url_path s
rs c C s6 t j| }|j }t|j|d}t j|j|dS )z
Make sure a link is fully quoted.
For example, if ' ' occurs in the URL, it will be replaced with "%20",
and without double-quoting other characters.
)rf )rH )rC rD urlparserG rs rH
urlunparse_replace)r resultrf rH r$ r$ r% _clean_link s rx )anchorrY base_urlr c C sL | d}|sdS ttj||}| d}| d}t||||d}|S )zJ
Convert an anchor element in a simple repository page to a Link.
rZ Nzdata-requires-pythonz data-yanked)
comes_fromrequires_python
yanked_reason)r: rx rC rD urljoinr )ry rY rz rZ r pyrequirer} linkr$ r$ r% _create_link_from_element s
r c @ s: e Zd ZdddddZeedddZed d
d ZdS ) CacheablePageContentHTMLPageNpager c C s |j s
J || _d S r* )cache_link_parsingr )r- r r$ r$ r% r, s
z CacheablePageContent.__init__)otherr c C s t |t| o | jj|jjkS r* )
isinstancetyper r )r- r r$ r$ r% __eq__ s zCacheablePageContent.__eq__r c C s t | jjS r* )hashr r r- r$ r$ r% __hash__ s z CacheablePageContent.__hash__) r0 r1 r2 r, objectboolr intr r$ r$ r$ r% r s r r )fnr c sL t jddttt d fdd t dtt d fdd }|S )
z
Given a function that parses an Iterable[Link] from an HTMLPage, cache the
function's result (keyed by CacheablePageContent), unless the HTMLPage
`page` has `page.cache_link_parsing == False`.
N)maxsize)cacheable_pager c s t | jS r* )listr )r )r r$ r% wrapper s z'with_cached_html_pages..wrapperr r c s | j rt| S t | S r* )r r r )r r r r$ r% wrapper_wrapper s z/with_cached_html_pages..wrapper_wrapper) functools lru_cacher r r wraps)r r r$ r r% with_cached_html_pages s
r r c c sV t j| j| jdd}| j}t||}|dD ]"}t|||d}|du rJq.|V q.dS )zP
Parse an HTML document, and yield its anchor elements as Link objects.
F)transport_encodingnamespaceHTMLElementsz.//a)rY rz N)r rD contentencodingr r] r[ r )r rX r rz ry r r$ r$ r% parse_links( s
r c @ s: e Zd ZdZd
eee eeddddZeddd Z dS ) r z'Represents one page, along with its URLTN)r r r r r c C s || _ || _|| _|| _dS )am
:param encoding: the encoding to decode the given content.
:param url: the URL from which the HTML was downloaded.
:param cache_link_parsing: whether links parsed from this page's url
should be cached. PyPI index urls should
have this set to False, for example.
N)r r r r )r- r r r r r$ r$ r% r, C s zHTMLPage.__init__r c C s
t | jS r* )r r r r$ r$ r% __str__V s zHTMLPage.__str__)T)
r0 r1 r2 __doc__bytesr r3 r r, r r$ r$ r$ r% r @ s ).N)r reasonmethr c C s |d u rt j}|d| | d S )Nz%Could not fetch URL %s: %s - skipping)rP rQ )r r r r$ r$ r% _handle_get_page_failZ s r T)r5 r r c C s t | j}t| j|| j|dS )N)r r r )rW r9 r r r )r5 r r r$ r$ r% _make_html_paged s
r )r r? r c
C s |d u rt d| jddd }t|}|r@td|| d S tj|\}}}}}}|dkrt j
tj
|r|ds|d7 }tj|d}td | zt||d
}W nN ty td | Y n> ty } z"td | |j|j W Y d }~n d }~0 ty: } zt| | W Y d }~nd }~0 tyh } zt| | W Y d }~nd }~0 ty } z,d
} | t|7 } t| | tjd W Y d }~nld }~0 t j y } z t| d| W Y d }~n6d }~0 t j y t| d Y n0 t || j dS d S )Nz?_get_html_page() missing 1 required keyword argument: 'session'#r r zICannot look at %s URL %s because it does not support lookup as web pages.file/z
index.htmlz# file: URL is directory, getting %srM z`Skipping page %s because it looks like an archive, and cannot be checked by a HTTP HEAD request.ziSkipping page %s because the %s request got Content-Type: %s.The only supported Content-Type is text/htmlz4There was a problem confirming the ssl certificate: )r zconnection error: z timed out)r )! TypeErrorr rh r& rP warningrC rD rt osrH isdirr; rd endswithr~ rQ rR r> r' r) r( r r r r r3 infor ConnectionErrorTimeoutr r )
r r? r
vcs_schemer# _rH rK excr r$ r$ r% _get_html_pagen s^
$$r c @ s. e Zd ZU eee ed< eee ed< dS )CollectedSources
find_links
index_urlsN)r0 r1 r2 r r r __annotations__r$ r$ r$ r% r s
r c @ sx e Zd ZdZeeddddZedeee d ddd Z
e e e
d
d d Zeee d
ddZe
eedddZdS )
LinkCollectorz
Responsible for collecting Link objects from all configured locations,
making network requests as needed.
The class's main method is its collect_sources() method.
N)r? search_scoper c C s || _ || _d S r* )r r? )r- r? r r$ r$ r% r, s zLinkCollector.__init__F)r? optionssuppress_no_indexr c C s` |j g|j }|jr8|s8tdddd |D g }|jp@g }tj||d}t ||d}|S )z
:param session: The Session to use to make requests.
:param suppress_no_index: Whether to ignore the --no-index option
when constructing the SearchScope object.
zIgnoring indexes: %s,c s s | ]}t |V qd S r* )r ).0r r$ r$ r% z'LinkCollector.create..r r )r? r )
index_urlextra_index_urlsno_indexrP rQ rm r r creater )clsr? r r r r r link_collectorr$ r$ r% r s"
zLinkCollector.creater c C s | j jS r* )r r r r$ r$ r% r s zLinkCollector.find_links)locationr c C s t || jdS )z>
Fetch an HTML page containing package links.
rM )r r? )r- r r$ r$ r%
fetch_page s zLinkCollector.fetch_page) project_namecandidates_from_pager c s t fddj|D }t fddjD }ttj rdd t
||D }t | d| dg| }t
d| tt|t|d S )
Nc 3 s$ | ] }t | jjd d dV qdS )Fr page_validator
expand_dirr Nr r? is_secure_originr locr r- r$ r% r s z0LinkCollector.collect_sources..c 3 s$ | ] }t | jjd d dV qdS )Tr Nr r r r$ r% r s c S s* g | ]"}|d ur|j d urd|j qS )Nz* )r )r sr$ r$ r%
s z1LinkCollector.collect_sources..z' location(s) to search for versions of :
r ) collections OrderedDictr get_index_urls_locationsvaluesr rP isEnabledForloggingDEBUGri rj r" rQ rm r r )r- r r index_url_sourcesfind_links_sourceslinesr$ r r% collect_sources s*
z LinkCollector.collect_sources)F)r0 r1 r2 r r r r, classmethodr r r propertyr r3 r r r r r r r r r$ r$ r$ r% r s( r )N)T)N)Yr rT r r ri r r re urllib.parserC urllib.requestxml.etree.ElementTreexmloptparser typingr r r r r r r r
pip._vendorr r Zpip._vendor.requestsr
Z pip._vendor.requests.exceptionsr r pip._internal.exceptionsr pip._internal.models.linkr !pip._internal.models.search_scoper pip._internal.network.sessionr pip._internal.network.utilsr pip._internal.utils.filetypesr pip._internal.utils.miscr r pip._internal.vcsr sourcesr r r getLoggerr0 rP etree ElementTreeElement HTMLElementr3 ResponseHeadersr& Exceptionr' r= r> rL rR rW r] rb re compile
IGNORECASErg r rs rx r r r r r r r r r r r$ r$ r$ r% s (
2
?PK ! +
sources.pynu [ import logging
import mimetypes
import os
import pathlib
from typing import Callable, Iterable, Optional, Tuple
from pip._internal.models.candidate import InstallationCandidate
from pip._internal.models.link import Link
from pip._internal.utils.urls import path_to_url, url_to_path
from pip._internal.vcs import is_url
logger = logging.getLogger(__name__)
FoundCandidates = Iterable[InstallationCandidate]
FoundLinks = Iterable[Link]
CandidatesFromPage = Callable[[Link], Iterable[InstallationCandidate]]
PageValidator = Callable[[Link], bool]
class LinkSource:
@property
def link(self) -> Optional[Link]:
"""Returns the underlying link, if there's one."""
raise NotImplementedError()
def page_candidates(self) -> FoundCandidates:
"""Candidates found by parsing an archive listing HTML file."""
raise NotImplementedError()
def file_links(self) -> FoundLinks:
"""Links found by specifying archives directly."""
raise NotImplementedError()
def _is_html_file(file_url: str) -> bool:
return mimetypes.guess_type(file_url, strict=False)[0] == "text/html"
class _FlatDirectorySource(LinkSource):
"""Link source specified by ``--find-links=``.
This looks the content of the directory, and returns:
* ``page_candidates``: Links listed on each HTML file in the directory.
* ``file_candidates``: Archives in the directory.
"""
def __init__(
self,
candidates_from_page: CandidatesFromPage,
path: str,
) -> None:
self._candidates_from_page = candidates_from_page
self._path = pathlib.Path(os.path.realpath(path))
@property
def link(self) -> Optional[Link]:
return None
def page_candidates(self) -> FoundCandidates:
for path in self._path.iterdir():
url = path_to_url(str(path))
if not _is_html_file(url):
continue
yield from self._candidates_from_page(Link(url))
def file_links(self) -> FoundLinks:
for path in self._path.iterdir():
url = path_to_url(str(path))
if _is_html_file(url):
continue
yield Link(url)
class _LocalFileSource(LinkSource):
"""``--find-links=`` or ``--[extra-]index-url=``.
If a URL is supplied, it must be a ``file:`` URL. If a path is supplied to
the option, it is converted to a URL first. This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
"""
def __init__(
self,
candidates_from_page: CandidatesFromPage,
link: Link,
) -> None:
self._candidates_from_page = candidates_from_page
self._link = link
@property
def link(self) -> Optional[Link]:
return self._link
def page_candidates(self) -> FoundCandidates:
if not _is_html_file(self._link.url):
return
yield from self._candidates_from_page(self._link)
def file_links(self) -> FoundLinks:
if _is_html_file(self._link.url):
return
yield self._link
class _RemoteFileSource(LinkSource):
"""``--find-links=`` or ``--[extra-]index-url=``.
This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
"""
def __init__(
self,
candidates_from_page: CandidatesFromPage,
page_validator: PageValidator,
link: Link,
) -> None:
self._candidates_from_page = candidates_from_page
self._page_validator = page_validator
self._link = link
@property
def link(self) -> Optional[Link]:
return self._link
def page_candidates(self) -> FoundCandidates:
if not self._page_validator(self._link):
return
yield from self._candidates_from_page(self._link)
def file_links(self) -> FoundLinks:
yield self._link
class _IndexDirectorySource(LinkSource):
"""``--[extra-]index-url=``.
This is treated like a remote URL; ``candidates_from_page`` contains logic
for this by appending ``index.html`` to the link.
"""
def __init__(
self,
candidates_from_page: CandidatesFromPage,
link: Link,
) -> None:
self._candidates_from_page = candidates_from_page
self._link = link
@property
def link(self) -> Optional[Link]:
return self._link
def page_candidates(self) -> FoundCandidates:
yield from self._candidates_from_page(self._link)
def file_links(self) -> FoundLinks:
return ()
def build_source(
location: str,
*,
candidates_from_page: CandidatesFromPage,
page_validator: PageValidator,
expand_dir: bool,
cache_link_parsing: bool,
) -> Tuple[Optional[str], Optional[LinkSource]]:
path: Optional[str] = None
url: Optional[str] = None
if os.path.exists(location): # Is a local path.
url = path_to_url(location)
path = location
elif location.startswith("file:"): # A file: URL.
url = location
path = url_to_path(location)
elif is_url(location):
url = location
if url is None:
msg = (
"Location '%s' is ignored: "
"it is either a non-existing path or lacks a specific scheme."
)
logger.warning(msg, location)
return (None, None)
if path is None:
source: LinkSource = _RemoteFileSource(
candidates_from_page=candidates_from_page,
page_validator=page_validator,
link=Link(url, cache_link_parsing=cache_link_parsing),
)
return (url, source)
if os.path.isdir(path):
if expand_dir:
source = _FlatDirectorySource(
candidates_from_page=candidates_from_page,
path=path,
)
else:
source = _IndexDirectorySource(
candidates_from_page=candidates_from_page,
link=Link(url, cache_link_parsing=cache_link_parsing),
)
return (url, source)
elif os.path.isfile(path):
source = _LocalFileSource(
candidates_from_page=candidates_from_page,
link=Link(url, cache_link_parsing=cache_link_parsing),
)
return (url, source)
logger.warning(
"Location '%s' is ignored: it is neither a file nor a directory.",
location,
)
return (url, None)
PK ! I~D ~D collector.pynu [ """
The main purpose of this module is to expose LinkCollector.collect_sources().
"""
import cgi
import collections
import functools
import itertools
import logging
import os
import re
import urllib.parse
import urllib.request
import xml.etree.ElementTree
from optparse import Values
from typing import (
Callable,
Iterable,
List,
MutableMapping,
NamedTuple,
Optional,
Sequence,
Union,
)
from pip._vendor import html5lib, requests
from pip._vendor.requests import Response
from pip._vendor.requests.exceptions import RetryError, SSLError
from pip._internal.exceptions import NetworkConnectionError
from pip._internal.models.link import Link
from pip._internal.models.search_scope import SearchScope
from pip._internal.network.session import PipSession
from pip._internal.network.utils import raise_for_status
from pip._internal.utils.filetypes import is_archive_file
from pip._internal.utils.misc import pairwise, redact_auth_from_url
from pip._internal.vcs import vcs
from .sources import CandidatesFromPage, LinkSource, build_source
logger = logging.getLogger(__name__)
HTMLElement = xml.etree.ElementTree.Element
ResponseHeaders = MutableMapping[str, str]
def _match_vcs_scheme(url: str) -> Optional[str]:
"""Look for VCS schemes in the URL.
Returns the matched VCS scheme, or None if there's no match.
"""
for scheme in vcs.schemes:
if url.lower().startswith(scheme) and url[len(scheme)] in "+:":
return scheme
return None
class _NotHTML(Exception):
def __init__(self, content_type: str, request_desc: str) -> None:
super().__init__(content_type, request_desc)
self.content_type = content_type
self.request_desc = request_desc
def _ensure_html_header(response: Response) -> None:
"""Check the Content-Type header to ensure the response contains HTML.
Raises `_NotHTML` if the content type is not text/html.
"""
content_type = response.headers.get("Content-Type", "")
if not content_type.lower().startswith("text/html"):
raise _NotHTML(content_type, response.request.method)
class _NotHTTP(Exception):
pass
def _ensure_html_response(url: str, session: PipSession) -> None:
"""Send a HEAD request to the URL, and ensure the response contains HTML.
Raises `_NotHTTP` if the URL is not available for a HEAD request, or
`_NotHTML` if the content type is not text/html.
"""
scheme, netloc, path, query, fragment = urllib.parse.urlsplit(url)
if scheme not in {"http", "https"}:
raise _NotHTTP()
resp = session.head(url, allow_redirects=True)
raise_for_status(resp)
_ensure_html_header(resp)
def _get_html_response(url: str, session: PipSession) -> Response:
"""Access an HTML page with GET, and return the response.
This consists of three parts:
1. If the URL looks suspiciously like an archive, send a HEAD first to
check the Content-Type is HTML, to avoid downloading a large file.
Raise `_NotHTTP` if the content type cannot be determined, or
`_NotHTML` if it is not HTML.
2. Actually perform the request. Raise HTTP exceptions on network failures.
3. Check the Content-Type header to make sure we got HTML, and raise
`_NotHTML` otherwise.
"""
if is_archive_file(Link(url).filename):
_ensure_html_response(url, session=session)
logger.debug("Getting page %s", redact_auth_from_url(url))
resp = session.get(
url,
headers={
"Accept": "text/html",
# We don't want to blindly returned cached data for
# /simple/, because authors generally expecting that
# twine upload && pip install will function, but if
# they've done a pip install in the last ~10 minutes
# it won't. Thus by setting this to zero we will not
# blindly use any cached data, however the benefit of
# using max-age=0 instead of no-cache, is that we will
# still support conditional requests, so we will still
# minimize traffic sent in cases where the page hasn't
# changed at all, we will just always incur the round
# trip for the conditional GET now instead of only
# once per 10 minutes.
# For more information, please see pypa/pip#5670.
"Cache-Control": "max-age=0",
},
)
raise_for_status(resp)
# The check for archives above only works if the url ends with
# something that looks like an archive. However that is not a
# requirement of an url. Unless we issue a HEAD request on every
# url we cannot know ahead of time for sure if something is HTML
# or not. However we can check after we've downloaded it.
_ensure_html_header(resp)
return resp
def _get_encoding_from_headers(headers: ResponseHeaders) -> Optional[str]:
"""Determine if we have any encoding information in our headers."""
if headers and "Content-Type" in headers:
content_type, params = cgi.parse_header(headers["Content-Type"])
if "charset" in params:
return params["charset"]
return None
def _determine_base_url(document: HTMLElement, page_url: str) -> str:
"""Determine the HTML document's base URL.
This looks for a ```` tag in the HTML document. If present, its href
attribute denotes the base URL of anchor tags in the document. If there is
no such tag (or if it does not have a valid href attribute), the HTML
file's URL is used as the base URL.
:param document: An HTML document representation. The current
implementation expects the result of ``html5lib.parse()``.
:param page_url: The URL of the HTML document.
"""
for base in document.findall(".//base"):
href = base.get("href")
if href is not None:
return href
return page_url
def _clean_url_path_part(part: str) -> str:
"""
Clean a "part" of a URL path (i.e. after splitting on "@" characters).
"""
# We unquote prior to quoting to make sure nothing is double quoted.
return urllib.parse.quote(urllib.parse.unquote(part))
def _clean_file_url_path(part: str) -> str:
"""
Clean the first part of a URL path that corresponds to a local
filesystem path (i.e. the first part after splitting on "@" characters).
"""
# We unquote prior to quoting to make sure nothing is double quoted.
# Also, on Windows the path part might contain a drive letter which
# should not be quoted. On Linux where drive letters do not
# exist, the colon should be quoted. We rely on urllib.request
# to do the right thing here.
return urllib.request.pathname2url(urllib.request.url2pathname(part))
# percent-encoded: /
_reserved_chars_re = re.compile("(@|%2F)", re.IGNORECASE)
def _clean_url_path(path: str, is_local_path: bool) -> str:
"""
Clean the path portion of a URL.
"""
if is_local_path:
clean_func = _clean_file_url_path
else:
clean_func = _clean_url_path_part
# Split on the reserved characters prior to cleaning so that
# revision strings in VCS URLs are properly preserved.
parts = _reserved_chars_re.split(path)
cleaned_parts = []
for to_clean, reserved in pairwise(itertools.chain(parts, [""])):
cleaned_parts.append(clean_func(to_clean))
# Normalize %xx escapes (e.g. %2f -> %2F)
cleaned_parts.append(reserved.upper())
return "".join(cleaned_parts)
def _clean_link(url: str) -> str:
"""
Make sure a link is fully quoted.
For example, if ' ' occurs in the URL, it will be replaced with "%20",
and without double-quoting other characters.
"""
# Split the URL into parts according to the general structure
# `scheme://netloc/path;parameters?query#fragment`.
result = urllib.parse.urlparse(url)
# If the netloc is empty, then the URL refers to a local filesystem path.
is_local_path = not result.netloc
path = _clean_url_path(result.path, is_local_path=is_local_path)
return urllib.parse.urlunparse(result._replace(path=path))
def _create_link_from_element(
anchor: HTMLElement,
page_url: str,
base_url: str,
) -> Optional[Link]:
"""
Convert an anchor element in a simple repository page to a Link.
"""
href = anchor.get("href")
if not href:
return None
url = _clean_link(urllib.parse.urljoin(base_url, href))
pyrequire = anchor.get("data-requires-python")
yanked_reason = anchor.get("data-yanked")
link = Link(
url,
comes_from=page_url,
requires_python=pyrequire,
yanked_reason=yanked_reason,
)
return link
class CacheablePageContent:
def __init__(self, page: "HTMLPage") -> None:
assert page.cache_link_parsing
self.page = page
def __eq__(self, other: object) -> bool:
return isinstance(other, type(self)) and self.page.url == other.page.url
def __hash__(self) -> int:
return hash(self.page.url)
def with_cached_html_pages(
fn: Callable[["HTMLPage"], Iterable[Link]],
) -> Callable[["HTMLPage"], List[Link]]:
"""
Given a function that parses an Iterable[Link] from an HTMLPage, cache the
function's result (keyed by CacheablePageContent), unless the HTMLPage
`page` has `page.cache_link_parsing == False`.
"""
@functools.lru_cache(maxsize=None)
def wrapper(cacheable_page: CacheablePageContent) -> List[Link]:
return list(fn(cacheable_page.page))
@functools.wraps(fn)
def wrapper_wrapper(page: "HTMLPage") -> List[Link]:
if page.cache_link_parsing:
return wrapper(CacheablePageContent(page))
return list(fn(page))
return wrapper_wrapper
@with_cached_html_pages
def parse_links(page: "HTMLPage") -> Iterable[Link]:
"""
Parse an HTML document, and yield its anchor elements as Link objects.
"""
document = html5lib.parse(
page.content,
transport_encoding=page.encoding,
namespaceHTMLElements=False,
)
url = page.url
base_url = _determine_base_url(document, url)
for anchor in document.findall(".//a"):
link = _create_link_from_element(
anchor,
page_url=url,
base_url=base_url,
)
if link is None:
continue
yield link
class HTMLPage:
"""Represents one page, along with its URL"""
def __init__(
self,
content: bytes,
encoding: Optional[str],
url: str,
cache_link_parsing: bool = True,
) -> None:
"""
:param encoding: the encoding to decode the given content.
:param url: the URL from which the HTML was downloaded.
:param cache_link_parsing: whether links parsed from this page's url
should be cached. PyPI index urls should
have this set to False, for example.
"""
self.content = content
self.encoding = encoding
self.url = url
self.cache_link_parsing = cache_link_parsing
def __str__(self) -> str:
return redact_auth_from_url(self.url)
def _handle_get_page_fail(
link: Link,
reason: Union[str, Exception],
meth: Optional[Callable[..., None]] = None,
) -> None:
if meth is None:
meth = logger.debug
meth("Could not fetch URL %s: %s - skipping", link, reason)
def _make_html_page(response: Response, cache_link_parsing: bool = True) -> HTMLPage:
encoding = _get_encoding_from_headers(response.headers)
return HTMLPage(
response.content,
encoding=encoding,
url=response.url,
cache_link_parsing=cache_link_parsing,
)
def _get_html_page(
link: Link, session: Optional[PipSession] = None
) -> Optional["HTMLPage"]:
if session is None:
raise TypeError(
"_get_html_page() missing 1 required keyword argument: 'session'"
)
url = link.url.split("#", 1)[0]
# Check for VCS schemes that do not support lookup as web pages.
vcs_scheme = _match_vcs_scheme(url)
if vcs_scheme:
logger.warning(
"Cannot look at %s URL %s because it does not support lookup as web pages.",
vcs_scheme,
link,
)
return None
# Tack index.html onto file:// URLs that point to directories
scheme, _, path, _, _, _ = urllib.parse.urlparse(url)
if scheme == "file" and os.path.isdir(urllib.request.url2pathname(path)):
# add trailing slash if not present so urljoin doesn't trim
# final segment
if not url.endswith("/"):
url += "/"
url = urllib.parse.urljoin(url, "index.html")
logger.debug(" file: URL is directory, getting %s", url)
try:
resp = _get_html_response(url, session=session)
except _NotHTTP:
logger.warning(
"Skipping page %s because it looks like an archive, and cannot "
"be checked by a HTTP HEAD request.",
link,
)
except _NotHTML as exc:
logger.warning(
"Skipping page %s because the %s request got Content-Type: %s."
"The only supported Content-Type is text/html",
link,
exc.request_desc,
exc.content_type,
)
except NetworkConnectionError as exc:
_handle_get_page_fail(link, exc)
except RetryError as exc:
_handle_get_page_fail(link, exc)
except SSLError as exc:
reason = "There was a problem confirming the ssl certificate: "
reason += str(exc)
_handle_get_page_fail(link, reason, meth=logger.info)
except requests.ConnectionError as exc:
_handle_get_page_fail(link, f"connection error: {exc}")
except requests.Timeout:
_handle_get_page_fail(link, "timed out")
else:
return _make_html_page(resp, cache_link_parsing=link.cache_link_parsing)
return None
class CollectedSources(NamedTuple):
find_links: Sequence[Optional[LinkSource]]
index_urls: Sequence[Optional[LinkSource]]
class LinkCollector:
"""
Responsible for collecting Link objects from all configured locations,
making network requests as needed.
The class's main method is its collect_sources() method.
"""
def __init__(
self,
session: PipSession,
search_scope: SearchScope,
) -> None:
self.search_scope = search_scope
self.session = session
@classmethod
def create(
cls,
session: PipSession,
options: Values,
suppress_no_index: bool = False,
) -> "LinkCollector":
"""
:param session: The Session to use to make requests.
:param suppress_no_index: Whether to ignore the --no-index option
when constructing the SearchScope object.
"""
index_urls = [options.index_url] + options.extra_index_urls
if options.no_index and not suppress_no_index:
logger.debug(
"Ignoring indexes: %s",
",".join(redact_auth_from_url(url) for url in index_urls),
)
index_urls = []
# Make sure find_links is a list before passing to create().
find_links = options.find_links or []
search_scope = SearchScope.create(
find_links=find_links,
index_urls=index_urls,
)
link_collector = LinkCollector(
session=session,
search_scope=search_scope,
)
return link_collector
@property
def find_links(self) -> List[str]:
return self.search_scope.find_links
def fetch_page(self, location: Link) -> Optional[HTMLPage]:
"""
Fetch an HTML page containing package links.
"""
return _get_html_page(location, session=self.session)
def collect_sources(
self,
project_name: str,
candidates_from_page: CandidatesFromPage,
) -> CollectedSources:
# The OrderedDict calls deduplicate sources by URL.
index_url_sources = collections.OrderedDict(
build_source(
loc,
candidates_from_page=candidates_from_page,
page_validator=self.session.is_secure_origin,
expand_dir=False,
cache_link_parsing=False,
)
for loc in self.search_scope.get_index_urls_locations(project_name)
).values()
find_links_sources = collections.OrderedDict(
build_source(
loc,
candidates_from_page=candidates_from_page,
page_validator=self.session.is_secure_origin,
expand_dir=True,
cache_link_parsing=True,
)
for loc in self.find_links
).values()
if logger.isEnabledFor(logging.DEBUG):
lines = [
f"* {s.link}"
for s in itertools.chain(find_links_sources, index_url_sources)
if s is not None and s.link is not None
]
lines = [
f"{len(lines)} location(s) to search "
f"for versions of {project_name}:"
] + lines
logger.debug("\n".join(lines))
return CollectedSources(
find_links=list(find_links_sources),
index_urls=list(index_url_sources),
)
PK ! C?K __init__.pynu [ """Index interaction code
"""
PK ! W package_finder.pynu [ """Routines related to PyPI, indexes"""
# The following comment should be removed at some point in the future.
# mypy: strict-optional=False
import functools
import itertools
import logging
import re
from typing import FrozenSet, Iterable, List, Optional, Set, Tuple, Union
from pip._vendor.packaging import specifiers
from pip._vendor.packaging.tags import Tag
from pip._vendor.packaging.utils import canonicalize_name
from pip._vendor.packaging.version import _BaseVersion
from pip._vendor.packaging.version import parse as parse_version
from pip._internal.exceptions import (
BestVersionAlreadyInstalled,
DistributionNotFound,
InvalidWheelFilename,
UnsupportedWheel,
)
from pip._internal.index.collector import LinkCollector, parse_links
from pip._internal.models.candidate import InstallationCandidate
from pip._internal.models.format_control import FormatControl
from pip._internal.models.link import Link
from pip._internal.models.search_scope import SearchScope
from pip._internal.models.selection_prefs import SelectionPreferences
from pip._internal.models.target_python import TargetPython
from pip._internal.models.wheel import Wheel
from pip._internal.req import InstallRequirement
from pip._internal.utils._log import getLogger
from pip._internal.utils.filetypes import WHEEL_EXTENSION
from pip._internal.utils.hashes import Hashes
from pip._internal.utils.logging import indent_log
from pip._internal.utils.misc import build_netloc
from pip._internal.utils.packaging import check_requires_python
from pip._internal.utils.unpacking import SUPPORTED_EXTENSIONS
from pip._internal.utils.urls import url_to_path
__all__ = ["FormatControl", "BestCandidateResult", "PackageFinder"]
logger = getLogger(__name__)
BuildTag = Union[Tuple[()], Tuple[int, str]]
CandidateSortingKey = Tuple[int, int, int, _BaseVersion, Optional[int], BuildTag]
def _check_link_requires_python(
link: Link,
version_info: Tuple[int, int, int],
ignore_requires_python: bool = False,
) -> bool:
"""
Return whether the given Python version is compatible with a link's
"Requires-Python" value.
:param version_info: A 3-tuple of ints representing the Python
major-minor-micro version to check.
:param ignore_requires_python: Whether to ignore the "Requires-Python"
value if the given Python version isn't compatible.
"""
try:
is_compatible = check_requires_python(
link.requires_python,
version_info=version_info,
)
except specifiers.InvalidSpecifier:
logger.debug(
"Ignoring invalid Requires-Python (%r) for link: %s",
link.requires_python,
link,
)
else:
if not is_compatible:
version = ".".join(map(str, version_info))
if not ignore_requires_python:
logger.verbose(
"Link requires a different Python (%s not in: %r): %s",
version,
link.requires_python,
link,
)
return False
logger.debug(
"Ignoring failed Requires-Python check (%s not in: %r) for link: %s",
version,
link.requires_python,
link,
)
return True
class LinkEvaluator:
"""
Responsible for evaluating links for a particular project.
"""
_py_version_re = re.compile(r"-py([123]\.?[0-9]?)$")
# Don't include an allow_yanked default value to make sure each call
# site considers whether yanked releases are allowed. This also causes
# that decision to be made explicit in the calling code, which helps
# people when reading the code.
def __init__(
self,
project_name: str,
canonical_name: str,
formats: FrozenSet[str],
target_python: TargetPython,
allow_yanked: bool,
ignore_requires_python: Optional[bool] = None,
) -> None:
"""
:param project_name: The user supplied package name.
:param canonical_name: The canonical package name.
:param formats: The formats allowed for this package. Should be a set
with 'binary' or 'source' or both in it.
:param target_python: The target Python interpreter to use when
evaluating link compatibility. This is used, for example, to
check wheel compatibility, as well as when checking the Python
version, e.g. the Python version embedded in a link filename
(or egg fragment) and against an HTML link's optional PEP 503
"data-requires-python" attribute.
:param allow_yanked: Whether files marked as yanked (in the sense
of PEP 592) are permitted to be candidates for install.
:param ignore_requires_python: Whether to ignore incompatible
PEP 503 "data-requires-python" values in HTML links. Defaults
to False.
"""
if ignore_requires_python is None:
ignore_requires_python = False
self._allow_yanked = allow_yanked
self._canonical_name = canonical_name
self._ignore_requires_python = ignore_requires_python
self._formats = formats
self._target_python = target_python
self.project_name = project_name
def evaluate_link(self, link: Link) -> Tuple[bool, Optional[str]]:
"""
Determine whether a link is a candidate for installation.
:return: A tuple (is_candidate, result), where `result` is (1) a
version string if `is_candidate` is True, and (2) if
`is_candidate` is False, an optional string to log the reason
the link fails to qualify.
"""
version = None
if link.is_yanked and not self._allow_yanked:
reason = link.yanked_reason or ""
return (False, f"yanked for reason: {reason}")
if link.egg_fragment:
egg_info = link.egg_fragment
ext = link.ext
else:
egg_info, ext = link.splitext()
if not ext:
return (False, "not a file")
if ext not in SUPPORTED_EXTENSIONS:
return (False, f"unsupported archive format: {ext}")
if "binary" not in self._formats and ext == WHEEL_EXTENSION:
reason = "No binaries permitted for {}".format(self.project_name)
return (False, reason)
if "macosx10" in link.path and ext == ".zip":
return (False, "macosx10 one")
if ext == WHEEL_EXTENSION:
try:
wheel = Wheel(link.filename)
except InvalidWheelFilename:
return (False, "invalid wheel filename")
if canonicalize_name(wheel.name) != self._canonical_name:
reason = "wrong project name (not {})".format(self.project_name)
return (False, reason)
supported_tags = self._target_python.get_tags()
if not wheel.supported(supported_tags):
# Include the wheel's tags in the reason string to
# simplify troubleshooting compatibility issues.
file_tags = wheel.get_formatted_file_tags()
reason = (
"none of the wheel's tags ({}) are compatible "
"(run pip debug --verbose to show compatible tags)".format(
", ".join(file_tags)
)
)
return (False, reason)
version = wheel.version
# This should be up by the self.ok_binary check, but see issue 2700.
if "source" not in self._formats and ext != WHEEL_EXTENSION:
reason = f"No sources permitted for {self.project_name}"
return (False, reason)
if not version:
version = _extract_version_from_fragment(
egg_info,
self._canonical_name,
)
if not version:
reason = f"Missing project version for {self.project_name}"
return (False, reason)
match = self._py_version_re.search(version)
if match:
version = version[: match.start()]
py_version = match.group(1)
if py_version != self._target_python.py_version:
return (False, "Python version is incorrect")
supports_python = _check_link_requires_python(
link,
version_info=self._target_python.py_version_info,
ignore_requires_python=self._ignore_requires_python,
)
if not supports_python:
# Return None for the reason text to suppress calling
# _log_skipped_link().
return (False, None)
logger.debug("Found link %s, version: %s", link, version)
return (True, version)
def filter_unallowed_hashes(
candidates: List[InstallationCandidate],
hashes: Hashes,
project_name: str,
) -> List[InstallationCandidate]:
"""
Filter out candidates whose hashes aren't allowed, and return a new
list of candidates.
If at least one candidate has an allowed hash, then all candidates with
either an allowed hash or no hash specified are returned. Otherwise,
the given candidates are returned.
Including the candidates with no hash specified when there is a match
allows a warning to be logged if there is a more preferred candidate
with no hash specified. Returning all candidates in the case of no
matches lets pip report the hash of the candidate that would otherwise
have been installed (e.g. permitting the user to more easily update
their requirements file with the desired hash).
"""
if not hashes:
logger.debug(
"Given no hashes to check %s links for project %r: "
"discarding no candidates",
len(candidates),
project_name,
)
# Make sure we're not returning back the given value.
return list(candidates)
matches_or_no_digest = []
# Collect the non-matches for logging purposes.
non_matches = []
match_count = 0
for candidate in candidates:
link = candidate.link
if not link.has_hash:
pass
elif link.is_hash_allowed(hashes=hashes):
match_count += 1
else:
non_matches.append(candidate)
continue
matches_or_no_digest.append(candidate)
if match_count:
filtered = matches_or_no_digest
else:
# Make sure we're not returning back the given value.
filtered = list(candidates)
if len(filtered) == len(candidates):
discard_message = "discarding no candidates"
else:
discard_message = "discarding {} non-matches:\n {}".format(
len(non_matches),
"\n ".join(str(candidate.link) for candidate in non_matches),
)
logger.debug(
"Checked %s links for project %r against %s hashes "
"(%s matches, %s no digest): %s",
len(candidates),
project_name,
hashes.digest_count,
match_count,
len(matches_or_no_digest) - match_count,
discard_message,
)
return filtered
class CandidatePreferences:
"""
Encapsulates some of the preferences for filtering and sorting
InstallationCandidate objects.
"""
def __init__(
self,
prefer_binary: bool = False,
allow_all_prereleases: bool = False,
) -> None:
"""
:param allow_all_prereleases: Whether to allow all pre-releases.
"""
self.allow_all_prereleases = allow_all_prereleases
self.prefer_binary = prefer_binary
class BestCandidateResult:
"""A collection of candidates, returned by `PackageFinder.find_best_candidate`.
This class is only intended to be instantiated by CandidateEvaluator's
`compute_best_candidate()` method.
"""
def __init__(
self,
candidates: List[InstallationCandidate],
applicable_candidates: List[InstallationCandidate],
best_candidate: Optional[InstallationCandidate],
) -> None:
"""
:param candidates: A sequence of all available candidates found.
:param applicable_candidates: The applicable candidates.
:param best_candidate: The most preferred candidate found, or None
if no applicable candidates were found.
"""
assert set(applicable_candidates) <= set(candidates)
if best_candidate is None:
assert not applicable_candidates
else:
assert best_candidate in applicable_candidates
self._applicable_candidates = applicable_candidates
self._candidates = candidates
self.best_candidate = best_candidate
def iter_all(self) -> Iterable[InstallationCandidate]:
"""Iterate through all candidates."""
return iter(self._candidates)
def iter_applicable(self) -> Iterable[InstallationCandidate]:
"""Iterate through the applicable candidates."""
return iter(self._applicable_candidates)
class CandidateEvaluator:
"""
Responsible for filtering and sorting candidates for installation based
on what tags are valid.
"""
@classmethod
def create(
cls,
project_name: str,
target_python: Optional[TargetPython] = None,
prefer_binary: bool = False,
allow_all_prereleases: bool = False,
specifier: Optional[specifiers.BaseSpecifier] = None,
hashes: Optional[Hashes] = None,
) -> "CandidateEvaluator":
"""Create a CandidateEvaluator object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:param hashes: An optional collection of allowed hashes.
"""
if target_python is None:
target_python = TargetPython()
if specifier is None:
specifier = specifiers.SpecifierSet()
supported_tags = target_python.get_tags()
return cls(
project_name=project_name,
supported_tags=supported_tags,
specifier=specifier,
prefer_binary=prefer_binary,
allow_all_prereleases=allow_all_prereleases,
hashes=hashes,
)
def __init__(
self,
project_name: str,
supported_tags: List[Tag],
specifier: specifiers.BaseSpecifier,
prefer_binary: bool = False,
allow_all_prereleases: bool = False,
hashes: Optional[Hashes] = None,
) -> None:
"""
:param supported_tags: The PEP 425 tags supported by the target
Python in order of preference (most preferred first).
"""
self._allow_all_prereleases = allow_all_prereleases
self._hashes = hashes
self._prefer_binary = prefer_binary
self._project_name = project_name
self._specifier = specifier
self._supported_tags = supported_tags
# Since the index of the tag in the _supported_tags list is used
# as a priority, precompute a map from tag to index/priority to be
# used in wheel.find_most_preferred_tag.
self._wheel_tag_preferences = {
tag: idx for idx, tag in enumerate(supported_tags)
}
def get_applicable_candidates(
self,
candidates: List[InstallationCandidate],
) -> List[InstallationCandidate]:
"""
Return the applicable candidates from a list of candidates.
"""
# Using None infers from the specifier instead.
allow_prereleases = self._allow_all_prereleases or None
specifier = self._specifier
versions = {
str(v)
for v in specifier.filter(
# We turn the version object into a str here because otherwise
# when we're debundled but setuptools isn't, Python will see
# packaging.version.Version and
# pkg_resources._vendor.packaging.version.Version as different
# types. This way we'll use a str as a common data interchange
# format. If we stop using the pkg_resources provided specifier
# and start using our own, we can drop the cast to str().
(str(c.version) for c in candidates),
prereleases=allow_prereleases,
)
}
# Again, converting version to str to deal with debundling.
applicable_candidates = [c for c in candidates if str(c.version) in versions]
filtered_applicable_candidates = filter_unallowed_hashes(
candidates=applicable_candidates,
hashes=self._hashes,
project_name=self._project_name,
)
return sorted(filtered_applicable_candidates, key=self._sort_key)
def _sort_key(self, candidate: InstallationCandidate) -> CandidateSortingKey:
"""
Function to pass as the `key` argument to a call to sorted() to sort
InstallationCandidates by preference.
Returns a tuple such that tuples sorting as greater using Python's
default comparison operator are more preferred.
The preference is as follows:
First and foremost, candidates with allowed (matching) hashes are
always preferred over candidates without matching hashes. This is
because e.g. if the only candidate with an allowed hash is yanked,
we still want to use that candidate.
Second, excepting hash considerations, candidates that have been
yanked (in the sense of PEP 592) are always less preferred than
candidates that haven't been yanked. Then:
If not finding wheels, they are sorted by version only.
If finding wheels, then the sort order is by version, then:
1. existing installs
2. wheels ordered via Wheel.support_index_min(self._supported_tags)
3. source archives
If prefer_binary was set, then all wheels are sorted above sources.
Note: it was considered to embed this logic into the Link
comparison operators, but then different sdist links
with the same version, would have to be considered equal
"""
valid_tags = self._supported_tags
support_num = len(valid_tags)
build_tag: BuildTag = ()
binary_preference = 0
link = candidate.link
if link.is_wheel:
# can raise InvalidWheelFilename
wheel = Wheel(link.filename)
try:
pri = -(
wheel.find_most_preferred_tag(
valid_tags, self._wheel_tag_preferences
)
)
except ValueError:
raise UnsupportedWheel(
"{} is not a supported wheel for this platform. It "
"can't be sorted.".format(wheel.filename)
)
if self._prefer_binary:
binary_preference = 1
if wheel.build_tag is not None:
match = re.match(r"^(\d+)(.*)$", wheel.build_tag)
build_tag_groups = match.groups()
build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
else: # sdist
pri = -(support_num)
has_allowed_hash = int(link.is_hash_allowed(self._hashes))
yank_value = -1 * int(link.is_yanked) # -1 for yanked.
return (
has_allowed_hash,
yank_value,
binary_preference,
candidate.version,
pri,
build_tag,
)
def sort_best_candidate(
self,
candidates: List[InstallationCandidate],
) -> Optional[InstallationCandidate]:
"""
Return the best candidate per the instance's sort order, or None if
no candidate is acceptable.
"""
if not candidates:
return None
best_candidate = max(candidates, key=self._sort_key)
return best_candidate
def compute_best_candidate(
self,
candidates: List[InstallationCandidate],
) -> BestCandidateResult:
"""
Compute and return a `BestCandidateResult` instance.
"""
applicable_candidates = self.get_applicable_candidates(candidates)
best_candidate = self.sort_best_candidate(applicable_candidates)
return BestCandidateResult(
candidates,
applicable_candidates=applicable_candidates,
best_candidate=best_candidate,
)
class PackageFinder:
"""This finds packages.
This is meant to match easy_install's technique for looking for
packages, by reading pages and looking for appropriate links.
"""
def __init__(
self,
link_collector: LinkCollector,
target_python: TargetPython,
allow_yanked: bool,
format_control: Optional[FormatControl] = None,
candidate_prefs: Optional[CandidatePreferences] = None,
ignore_requires_python: Optional[bool] = None,
) -> None:
"""
This constructor is primarily meant to be used by the create() class
method and from tests.
:param format_control: A FormatControl object, used to control
the selection of source packages / binary packages when consulting
the index and links.
:param candidate_prefs: Options to use when creating a
CandidateEvaluator object.
"""
if candidate_prefs is None:
candidate_prefs = CandidatePreferences()
format_control = format_control or FormatControl(set(), set())
self._allow_yanked = allow_yanked
self._candidate_prefs = candidate_prefs
self._ignore_requires_python = ignore_requires_python
self._link_collector = link_collector
self._target_python = target_python
self.format_control = format_control
# These are boring links that have already been logged somehow.
self._logged_links: Set[Link] = set()
# Don't include an allow_yanked default value to make sure each call
# site considers whether yanked releases are allowed. This also causes
# that decision to be made explicit in the calling code, which helps
# people when reading the code.
@classmethod
def create(
cls,
link_collector: LinkCollector,
selection_prefs: SelectionPreferences,
target_python: Optional[TargetPython] = None,
) -> "PackageFinder":
"""Create a PackageFinder.
:param selection_prefs: The candidate selection preferences, as a
SelectionPreferences object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
"""
if target_python is None:
target_python = TargetPython()
candidate_prefs = CandidatePreferences(
prefer_binary=selection_prefs.prefer_binary,
allow_all_prereleases=selection_prefs.allow_all_prereleases,
)
return cls(
candidate_prefs=candidate_prefs,
link_collector=link_collector,
target_python=target_python,
allow_yanked=selection_prefs.allow_yanked,
format_control=selection_prefs.format_control,
ignore_requires_python=selection_prefs.ignore_requires_python,
)
@property
def target_python(self) -> TargetPython:
return self._target_python
@property
def search_scope(self) -> SearchScope:
return self._link_collector.search_scope
@search_scope.setter
def search_scope(self, search_scope: SearchScope) -> None:
self._link_collector.search_scope = search_scope
@property
def find_links(self) -> List[str]:
return self._link_collector.find_links
@property
def index_urls(self) -> List[str]:
return self.search_scope.index_urls
@property
def trusted_hosts(self) -> Iterable[str]:
for host_port in self._link_collector.session.pip_trusted_origins:
yield build_netloc(*host_port)
@property
def allow_all_prereleases(self) -> bool:
return self._candidate_prefs.allow_all_prereleases
def set_allow_all_prereleases(self) -> None:
self._candidate_prefs.allow_all_prereleases = True
@property
def prefer_binary(self) -> bool:
return self._candidate_prefs.prefer_binary
def set_prefer_binary(self) -> None:
self._candidate_prefs.prefer_binary = True
def make_link_evaluator(self, project_name: str) -> LinkEvaluator:
canonical_name = canonicalize_name(project_name)
formats = self.format_control.get_allowed_formats(canonical_name)
return LinkEvaluator(
project_name=project_name,
canonical_name=canonical_name,
formats=formats,
target_python=self._target_python,
allow_yanked=self._allow_yanked,
ignore_requires_python=self._ignore_requires_python,
)
def _sort_links(self, links: Iterable[Link]) -> List[Link]:
"""
Returns elements of links in order, non-egg links first, egg links
second, while eliminating duplicates
"""
eggs, no_eggs = [], []
seen: Set[Link] = set()
for link in links:
if link not in seen:
seen.add(link)
if link.egg_fragment:
eggs.append(link)
else:
no_eggs.append(link)
return no_eggs + eggs
def _log_skipped_link(self, link: Link, reason: str) -> None:
if link not in self._logged_links:
# Put the link at the end so the reason is more visible and because
# the link string is usually very long.
logger.debug("Skipping link: %s: %s", reason, link)
self._logged_links.add(link)
def get_install_candidate(
self, link_evaluator: LinkEvaluator, link: Link
) -> Optional[InstallationCandidate]:
"""
If the link is a candidate for install, convert it to an
InstallationCandidate and return it. Otherwise, return None.
"""
is_candidate, result = link_evaluator.evaluate_link(link)
if not is_candidate:
if result:
self._log_skipped_link(link, reason=result)
return None
return InstallationCandidate(
name=link_evaluator.project_name,
link=link,
version=result,
)
def evaluate_links(
self, link_evaluator: LinkEvaluator, links: Iterable[Link]
) -> List[InstallationCandidate]:
"""
Convert links that are candidates to InstallationCandidate objects.
"""
candidates = []
for link in self._sort_links(links):
candidate = self.get_install_candidate(link_evaluator, link)
if candidate is not None:
candidates.append(candidate)
return candidates
def process_project_url(
self, project_url: Link, link_evaluator: LinkEvaluator
) -> List[InstallationCandidate]:
logger.debug(
"Fetching project page and analyzing links: %s",
project_url,
)
html_page = self._link_collector.fetch_page(project_url)
if html_page is None:
return []
page_links = list(parse_links(html_page))
with indent_log():
package_links = self.evaluate_links(
link_evaluator,
links=page_links,
)
return package_links
@functools.lru_cache(maxsize=None)
def find_all_candidates(self, project_name: str) -> List[InstallationCandidate]:
"""Find all available InstallationCandidate for project_name
This checks index_urls and find_links.
All versions found are returned as an InstallationCandidate list.
See LinkEvaluator.evaluate_link() for details on which files
are accepted.
"""
link_evaluator = self.make_link_evaluator(project_name)
collected_sources = self._link_collector.collect_sources(
project_name=project_name,
candidates_from_page=functools.partial(
self.process_project_url,
link_evaluator=link_evaluator,
),
)
page_candidates_it = itertools.chain.from_iterable(
source.page_candidates()
for sources in collected_sources
for source in sources
if source is not None
)
page_candidates = list(page_candidates_it)
file_links_it = itertools.chain.from_iterable(
source.file_links()
for sources in collected_sources
for source in sources
if source is not None
)
file_candidates = self.evaluate_links(
link_evaluator,
sorted(file_links_it, reverse=True),
)
if logger.isEnabledFor(logging.DEBUG) and file_candidates:
paths = [url_to_path(c.link.url) for c in file_candidates]
logger.debug("Local files found: %s", ", ".join(paths))
# This is an intentional priority ordering
return file_candidates + page_candidates
def make_candidate_evaluator(
self,
project_name: str,
specifier: Optional[specifiers.BaseSpecifier] = None,
hashes: Optional[Hashes] = None,
) -> CandidateEvaluator:
"""Create a CandidateEvaluator object to use."""
candidate_prefs = self._candidate_prefs
return CandidateEvaluator.create(
project_name=project_name,
target_python=self._target_python,
prefer_binary=candidate_prefs.prefer_binary,
allow_all_prereleases=candidate_prefs.allow_all_prereleases,
specifier=specifier,
hashes=hashes,
)
@functools.lru_cache(maxsize=None)
def find_best_candidate(
self,
project_name: str,
specifier: Optional[specifiers.BaseSpecifier] = None,
hashes: Optional[Hashes] = None,
) -> BestCandidateResult:
"""Find matches for the given project and specifier.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:return: A `BestCandidateResult` instance.
"""
candidates = self.find_all_candidates(project_name)
candidate_evaluator = self.make_candidate_evaluator(
project_name=project_name,
specifier=specifier,
hashes=hashes,
)
return candidate_evaluator.compute_best_candidate(candidates)
def find_requirement(
self, req: InstallRequirement, upgrade: bool
) -> Optional[InstallationCandidate]:
"""Try to find a Link matching req
Expects req, an InstallRequirement and upgrade, a boolean
Returns a InstallationCandidate if found,
Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
"""
hashes = req.hashes(trust_internet=False)
best_candidate_result = self.find_best_candidate(
req.name,
specifier=req.specifier,
hashes=hashes,
)
best_candidate = best_candidate_result.best_candidate
installed_version: Optional[_BaseVersion] = None
if req.satisfied_by is not None:
installed_version = parse_version(req.satisfied_by.version)
def _format_versions(cand_iter: Iterable[InstallationCandidate]) -> str:
# This repeated parse_version and str() conversion is needed to
# handle different vendoring sources from pip and pkg_resources.
# If we stop using the pkg_resources provided specifier and start
# using our own, we can drop the cast to str().
return (
", ".join(
sorted(
{str(c.version) for c in cand_iter},
key=parse_version,
)
)
or "none"
)
if installed_version is None and best_candidate is None:
logger.critical(
"Could not find a version that satisfies the requirement %s "
"(from versions: %s)",
req,
_format_versions(best_candidate_result.iter_all()),
)
raise DistributionNotFound(
"No matching distribution found for {}".format(req)
)
best_installed = False
if installed_version and (
best_candidate is None or best_candidate.version <= installed_version
):
best_installed = True
if not upgrade and installed_version is not None:
if best_installed:
logger.debug(
"Existing installed version (%s) is most up-to-date and "
"satisfies requirement",
installed_version,
)
else:
logger.debug(
"Existing installed version (%s) satisfies requirement "
"(most up-to-date version is %s)",
installed_version,
best_candidate.version,
)
return None
if best_installed:
# We have an existing version, and its the best version
logger.debug(
"Installed version (%s) is most up-to-date (past versions: %s)",
installed_version,
_format_versions(best_candidate_result.iter_applicable()),
)
raise BestVersionAlreadyInstalled
logger.debug(
"Using version %s (newest of versions: %s)",
best_candidate.version,
_format_versions(best_candidate_result.iter_applicable()),
)
return best_candidate
def _find_name_version_sep(fragment: str, canonical_name: str) -> int:
"""Find the separator's index based on the package's canonical name.
:param fragment: A + filename "fragment" (stem) or
egg fragment.
:param canonical_name: The package's canonical name.
This function is needed since the canonicalized name does not necessarily
have the same length as the egg info's name part. An example::
>>> fragment = 'foo__bar-1.0'
>>> canonical_name = 'foo-bar'
>>> _find_name_version_sep(fragment, canonical_name)
8
"""
# Project name and version must be separated by one single dash. Find all
# occurrences of dashes; if the string in front of it matches the canonical
# name, this is the one separating the name and version parts.
for i, c in enumerate(fragment):
if c != "-":
continue
if canonicalize_name(fragment[:i]) == canonical_name:
return i
raise ValueError(f"{fragment} does not match {canonical_name}")
def _extract_version_from_fragment(fragment: str, canonical_name: str) -> Optional[str]:
"""Parse the version string from a + filename
"fragment" (stem) or egg fragment.
:param fragment: The string to parse. E.g. foo-2.1
:param canonical_name: The canonicalized name of the package this
belongs to.
"""
try:
version_start = _find_name_version_sep(fragment, canonical_name) + 1
except ValueError:
return None
version = fragment[version_start:]
if not version:
return None
return version
PK ! 9
$ __pycache__/__init__.cpython-311.pycnu [
i
d Z dS )zIndex interaction codeN)__doc__ |/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/pip/_internal/index/__init__.pyr s r PK ! { `n4 4 * __pycache__/package_finder.cpython-311.pycnu [
i0 8 d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl
mZmZmZ ddlmZ ddlmZ dd lmZmZ dd
lmZmZmZ dd lm Z dd l m Z m Z m!Z!m"Z"m#Z# dd
l$m%Z%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;mZ> ddl?m@Z@ ddlAmBZB dd lCmDZD dd lEmFZF dd lGmHZH erdd lImJZJ g d ZK e d? Z[dIdCZ\dJdEZ]dS )Kz!Routines related to PyPI, indexes ) annotationsN)Iterable) dataclass)
TYPE_CHECKINGOptionalUnion)
specifiers)Tag)NormalizedNamecanonicalize_name)InvalidVersionVersion _BaseVersion)parse)BestVersionAlreadyInstalledDistributionNotFoundInstallationErrorInvalidWheelFilenameUnsupportedWheel)
LinkCollector parse_links)select_backend)InstallationCandidate)
FormatControl)Link)ReleaseControl) SearchScope)SelectionPreferences) TargetPython)Wheel)InstallRequirement) getLogger)WHEEL_EXTENSION)Hashes)
indent_log) build_netloc)check_requires_python)SUPPORTED_EXTENSIONS) TypeGuard)r BestCandidateResult
PackageFinder Flinkr version_infotuple[int, int, int]ignore_requires_pythonboolreturnc t | j | }|spd t t | }|s$t
d|| j | dS t
d|| j | n6# t j $ r$ t
d| j | Y nw xY wdS )aa
Return whether the given Python version is compatible with a link's
"Requires-Python" value.
:param version_info: A 3-tuple of ints representing the Python
major-minor-micro version to check.
:param ignore_requires_python: Whether to ignore the "Requires-Python"
value if the given Python version isn't compatible.
)r. .z4Link requires a different Python (%s not in: %r): %sFzBIgnoring failed Requires-Python check (%s not in: %r) for link: %sz2Ignoring invalid Requires-Python (%r) for link: %sT)
r' requires_pythonjoinmapstrloggerverbosedebugr InvalidSpecifier)r- r. r0
is_compatibleversions /builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/pip/_internal/index/package_finder.py_check_link_requires_pythonr@ ? s - %
hhs3 5 566G)
J( u LLT$
% &
@
2 4s B 0B>=B>c e Zd Z ej Z ej Z ej Z ej Z ej Z ej Z
ej Z ej Z ej Z
dS )LinkTypeN)__name__
__module__ __qualname__enumauto candidatedifferent_projectyankedformat_unsupportedformat_invalidplatform_mismatchrequires_python_mismatchupload_too_lateupload_time_missingr, r? rB rB n s I!
TY[[F" TY[[N! (ty{{ dikkO#$)++rQ rB c H e Zd ZdZ ej d Z dddZddZdS )
LinkEvaluatorzD
Responsible for evaluating links for a particular project.
z-py([123]\.?[0-9]?)$N project_namer8 canonical_namer formatsfrozenset[str]
target_pythonr allow_yankedr1 r0 bool | Noneuploaded_prior_todatetime.datetime | Noner2 Nonec p |d}|| _ || _ || _ || _ || _ || _ || _ dS )aB
:param project_name: The user supplied package name.
:param canonical_name: The canonical package name.
:param formats: The formats allowed for this package. Should be a set
with 'binary' or 'source' or both in it.
:param target_python: The target Python interpreter to use when
evaluating link compatibility. This is used, for example, to
check wheel compatibility, as well as when checking the Python
version, e.g. the Python version embedded in a link filename
(or egg fragment) and against an HTML link's optional PEP 503
"data-requires-python" attribute.
:param allow_yanked: Whether files marked as yanked (in the sense
of PEP 592) are permitted to be candidates for install.
:param ignore_requires_python: Whether to ignore incompatible
PEP 503 "data-requires-python" values in HTML links. Defaults
to False.
:param uploaded_prior_to: If set, only allow links uploaded prior to
the given datetime.
NF)
_allow_yanked_canonical_name_ignore_requires_python_formats_target_python_uploaded_prior_torT )selfrT rU rV rX rY r0 r[ s r? __init__zLinkEvaluator.__init__ sM : " )%* " ) - '=$
+"3 (rQ r- r tuple[LinkType, str]c d}|j r!| j s|j pd}t j d| fS |j r|j }|j }nb| \ }}|st j dfS |t vrt j d| fS d| j
vr#|t k rd| j }t j |fS d|j
v r|d k rt j d
fS |t k r t |j }n # t $ r t j d fcY S w xY w|j | j k rd | j d
}t j |fS | j }| | s;d | }d| d}t j |fS |j }| j a|j sZ|j %|j r d|j } nd} t j | dfS |j | j k r t j! d|j d| j fS d| j
vr#|t k rd| j }t j |fS |stE || j }|sd| j }t j |fS | j# $ | }
|
rO|d|
% }|
& d } | | j j' k rt j dfS tQ || j j) | j* } | sb|j+ }
|
rDd&d }d! tY d" t[ j. |
D |# }
| d$|
}t j/ |fS t` 1 d%|| t j2 |fS )'a
Determine whether a link is a candidate for installation.
:return: A tuple (result, detail), where *result* is an enum
representing whether the evaluation found a candidate, or the reason
why one is not found. If a candidate is found, *detail* will be the
candidate's version string; if one is not found, it contains the
reason the link fails to qualify.
Nz zyanked for reason: z
not a filez unsupported archive format: binaryzNo binaries permitted for macosx10z.zipz macosx10 onezinvalid wheel filenamezwrong project name (not ), znone of the wheel's tags (zB) are compatible (run pip debug --verbose to show compatible tags)zIndex Indexz' does not provide upload-time metadata.z Upload time z not prior to sourcezNo sources permitted for z Missing project version for zPython version is incorrect)r. r0 vr8 r2 tuple[int, ...]c Z t d | d D S )Nc 3 \ K | ]'}| t | V (d S N)isdigitint.0ss r? zLLinkEvaluator.evaluate_link..get_version_sort_key.. s5 M MA MQ M M M M M MrQ r4 )tuplesplit)rp s r? get_version_sort_keyz9LinkEvaluator.evaluate_link..get_version_sort_key s) M M M M MMMMrQ ,c 3 4 K | ]}t | V d S rt )r8 rw s r? rz z.LinkEvaluator.evaluate_link.." s( RRAQRRRRRRrQ keyz Requires-Python zFound link %s, version: %s)rp r8 r2 rq )3 is_yankedr_
yanked_reasonrB rJ egg_fragmentextsplitextrK r( rb r# rT pathr filenamer rL namer` rI rc get_unsorted_tags supportedr6 get_formatted_file_tagsrM r> rd is_file upload_time
comes_fromrP rO _extract_version_from_fragment_py_version_researchstartgroup
py_versionr@ py_version_infora r5 sortedr SpecifierSetrN r9 r; rH )re r- r> reasonegg_infor wheelsupported_tags file_tags
index_infomatchr supports_pythonr5 r} s r?
evaluate_linkzLinkEvaluator.evaluate_link s > E$"4 E'9>F O%C6%C%CD D ( ((H(CC MMOOMHc
C 3\BB... /8388 t},,1G1GId6GII 3V<<TY&&3&== 3^DDo%% !$- 0 0EE+ /0
:!555 L8I L L LF $ 6??!%!4!F!F!H!H ~66 @ !% %*G*G*I*I J JIMY M M M % 6?? -
" .t| . '? )!;$/!;!;JJ!(J 0!JJJ !T%<<< ,:4#3 : : $ 7: : 4= ( (SO-C-CD1BDDF /8 8 4$ G 5GD4EGGF +V4 4#**733 o
o.G Q JT 0 ;;; .1
6 ,<#'#?
? " 2O
N N N N #&((RR)@ )Q)QRRR 0 # # CC/CCF 5v> > 14AAA"G,,s C- -DDNN)rT r8 rU r rV rW rX r rY r1 r0 rZ r[ r\ r2 r] )r- r r2 rg ) rC rD rE __doc__recompiler rf r r, rQ r? rS rS z sn RZ 788N /36:') ') ') ') ')R}- }- }- }- }- }-rQ rS
candidateslist[InstallationCandidate]hashes
Hashes | NonerT r8 c
|s8t dt | | t | S g }g }d}| D ]X}|j }|j sn2| | r|dz
}n| | C| | Y|r|}nt | }t | t | k rd} n@d t | d d |D } t d t | ||j
|t | |z
| |S )
a
Filter out candidates whose hashes aren't allowed, and return a new
list of candidates.
If at least one candidate has an allowed hash, then all candidates with
either an allowed hash or no hash specified are returned. Otherwise,
the given candidates are returned.
Including the candidates with no hash specified when there is a match
allows a warning to be logged if there is a more preferred candidate
with no hash specified. Returning all candidates in the case of no
matches lets pip report the hash of the candidate that would otherwise
have been installed (e.g. permitting the user to more easily update
their requirements file with the desired hash).
zJGiven no hashes to check %s links for project %r: discarding no candidatesr )r ro zdiscarding no candidatesz discarding {} non-matches:
{}z
c 3 > K | ]}t |j V d S rt )r8 r- )rx rH s r? rz z*filter_unallowed_hashes..g s, II IN++IIIIIIrQ zPChecked %s links for project %r against %s hashes (%s matches, %s no digest): %s) r9 r; lenlistr- has_hashis_hash_allowedappendformatr6 digest_count)
r r rT matches_or_no_digest non_matches match_countrH r- filtereddiscard_messages
r? filter_unallowed_hashesr . s (
'
OO
J KK
/
/ ~}
!
!
!
0
0 1 KK y ) ) ) ##I.... $'
##
8}}J''4<CC KKII[III I I
LL ) J !!K/ OrQ c 0 e Zd ZU dZdZded< dZded< dS )CandidatePreferenceszk
Encapsulates some of the preferences for filtering and sorting
InstallationCandidate objects.
Fr1
prefer_binaryNReleaseControl | Nonerelease_control)rC rD rE r r __annotations__r r, rQ r? r r x s@
M -1O111111rQ r T)frozenc : e Zd ZU dZded< ded< ded< d d Zd
S ) r* a A collection of candidates, returned by `PackageFinder.find_best_candidate`.
This class is only intended to be instantiated by CandidateEvaluator's
`compute_best_candidate()` method.
:param all_candidates: A sequence of all available candidates found.
:param applicable_candidates: The applicable candidates.
:param best_candidate: The most preferred candidate found, or None
if no applicable candidates were found.
r all_candidatesapplicable_candidates InstallationCandidate | Nonebest_candidater2 r] c t | j t | j k sJ | j | j rJ d S | j | j v sJ d S rt )setr r r re s r?
__post_init__z!BestCandidateResult.__post_init__ sd 4-..#d6I2J2JJJJJ &1 1 11 1 1&$*DDDDDDDrQ Nr2 r] )rC rD rE r r r r, rQ r? r* r* s` 0///66660000E E E E E ErQ r* c f e Zd ZdZe d"d#d Z d$d%dZd&dZd'd Zd(d Z d)d!Z
dS )*CandidateEvaluatorzm
Responsible for filtering and sorting candidates for installation based
on what tags are valid.
NFrT r8 rX TargetPython | Noner r1 r r specifier specifiers.BaseSpecifier | Noner r r2 c |t }|t j }| } | |||||| S )a Create a CandidateEvaluator object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:param hashes: An optional collection of allowed hashes.
N)rT r r r r r )r r r get_sorted_tags)clsrT rX r r r r r s r? createzCandidateEvaluator.create sc ( (NNM "/11I&6688s%) ' +
rQ r list[Tag]specifiers.BaseSpecifierr] c || _ || _ || _ || _ || _ || _ d t
| D | _ dS )z
:param supported_tags: The PEP 425 tags supported by the target
Python in order of preference (most preferred first).
c i | ]\ }}|| S r, r, )rx idxtags r?
z/CandidateEvaluator.__init__.. s+ '
'
'
!cC'
'
'
rQ N)_release_control_hashes_prefer_binary
_project_name
_specifier_supported_tags enumerate_wheel_tag_preferences)re rT r r r r r s r? rf zCandidateEvaluator.__init__ sa !0 + )# - '
'
%.~%>%>'
'
'
###rQ r r c | j -| j t | j }nd}| j }t j dk r
d |D }n d |D }t | d |D | fd|D }t || j
| j }t || j S )
zM
Return the applicable candidates from a list of candidates.
N
pkg_resourcesc : g | ]}|t |j fS r, r8 r> rx cs r?
z@CandidateEvaluator.get_applicable_candidates.. s% 999!S^^$999rQ c g | ] }||j f S r, r> r s r? r z@CandidateEvaluator.get_applicable_candidates.. s &J&J&J!19~&J&J&JrQ c 3 K | ] \ }}|V
d S rt r, )rx _rp s r? rz z?CandidateEvaluator.get_applicable_candidates.. s& 77tq!777777rQ ) prereleasesc " g | ] \ }}|v | S r, r, )rx r rp versionss r? r z@CandidateEvaluator.get_applicable_candidates.. s" X X Xtq!!x-----rQ )r r rT r )
r allows_prereleasesr r r r NAMEr filterr r r _sort_key)re r allow_prereleasesr candidates_and_versionsr filtered_applicable_candidatesr s @r? get_applicable_candidatesz,CandidateEvaluator.get_applicable_candidates s$ , $ 5 H H!$"455! ! !% O O 3 3 :9j999
$ # 'K&Jz&J&J&J # 77 6777 -
!Y X X X/F X X X )@,< +*
*
*
& 4$.IIIIrQ rH r CandidateSortingKeyc | j }t | }d}d}|j }|j rht |j } | || j }n%# t $ r t |j d w xY w| j
rd}|j }n| }t |
| j } dt |j z }
| |
||j ||fS )a)
Function to pass as the `key` argument to a call to sorted() to sort
InstallationCandidates by preference.
Returns a tuple such that tuples sorting as greater using Python's
default comparison operator are more preferred.
The preference is as follows:
First and foremost, candidates with allowed (matching) hashes are
always preferred over candidates without matching hashes. This is
because e.g. if the only candidate with an allowed hash is yanked,
we still want to use that candidate.
Second, excepting hash considerations, candidates that have been
yanked (in the sense of PEP 592) are always less preferred than
candidates that haven't been yanked. Then:
If not finding wheels, they are sorted by version only.
If finding wheels, then the sort order is by version, then:
1. existing installs
2. wheels ordered via Wheel.support_index_min(self._supported_tags)
3. source archives
If prefer_binary was set, then all wheels are sorted above sources.
Note: it was considered to embed this logic into the Link
comparison operators, but then different sdist links
with the same version, would have to be considered equal
r, r z@ is not a supported wheel for this platform. It can't be sorted.ro )r r r- is_wheelr r find_most_preferred_tagr
ValueErrorr r build_tagrv r r r r> ) re rH
valid_tags support_numr binary_preferencer- r prihas_allowed_hash
yank_values r? r z CandidateEvaluator._sort_key s" < )
*oo ~ = !$-((E
11"D$?
& ~ ' ' '
"
&$%! II .C t 3 3DL A ABB#dn---
s A "A=r c : |sdS t || j }|S )zy
Return the best candidate per the instance's sort order, or None if
no candidate is acceptable.
Nr )maxr )re r r s r? sort_best_candidatez&CandidateEvaluator.sort_best_candidateO s+ 4 ZT^<<< rQ r* c z | | }| | }t ||| S )zF
Compute and return a `BestCandidateResult` instance.
)r r )r r r* )re r r r s r? compute_best_candidatez)CandidateEvaluator.compute_best_candidate\ sL !% > >z J J 112GHH" "7)
rQ )NFNNN)rT r8 rX r r r1 r r r r r r r2 r )FNN)rT r8 r r r r r r1 r r r r r2 r] )r r r2 r )rH r r2 r )r r r2 r )r r r2 r* ) rC rD rE r classmethodr rf r r r r r, rQ r? r r s
.2 #1559 $!
!
!
!
[!
P $15 $
4+J +J +J +JZ?
?
?
?
B
rQ r c e Zd ZdZ dQdRdZe dSdTd ZedUd ZedVd Z e j
dWd Z edXd Z edXd Z edYd! Z
edZd# ZedYd$ ZedYd% Zed[d' Zd\d*Zed]d+ Zd^d,Zed_d- ZdXd.Zd`d2Zdad6Zdbd<Zdcd?ZdddAZdedCZ dfdDZ dSdgdJZ dSdhdLZ didPZ dS )jr+ zThis finds packages.
This is meant to match easy_install's technique for looking for
packages, by reading pages and looking for appropriate links.
Nlink_collectorr rX r rY r1 format_controlFormatControl | Nonecandidate_prefsCandidatePreferences | Noner0 rZ r[ r\ r2 r] c |t }|p't t t }|| _ || _ || _ || _ || _ || _ || _ t | _
i | _ i | _ dS )a
This constructor is primarily meant to be used by the create() class
method and from tests.
:param format_control: A FormatControl object, used to control
the selection of source packages / binary packages when consulting
the index and links.
:param candidate_prefs: Options to use when creating a
CandidateEvaluator object.
N)
r r r r_ _candidate_prefsra _link_collectorrc rd r
_logged_links_all_candidates_best_candidates)re r rX rY r
r r0 r[ s r? rf zPackageFinder.__init__u s ( " 2 4 4O'F=+F+F ) / '=$ - +"3 , ?Bee HJ
rQ selection_prefsr r c |t }t |j |j } | ||||j |j |j | S )a Create a PackageFinder.
:param selection_prefs: The candidate selection preferences, as a
SelectionPreferences object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
:param uploaded_prior_to: If set, only find links uploaded prior
to the given datetime.
N)r r )r r rX rY r
r0 r[ )r r r r rY r
r0 )r r r rX r[ r s r? r zPackageFinder.create sl $ (NNM.)7 + ;
s +)'(5*9#2#I /
rQ c | j S rt )rc r s r? rX zPackageFinder.target_python s ""rQ r c | j j S rt r search_scoper s r? r zPackageFinder.search_scope s #00rQ r c || j _ d S rt r )re r s r? r zPackageFinder.search_scope s ,8 )))rQ list[str]c | j j S rt )r
find_linksr s r? r zPackageFinder.find_links s #..rQ c | j j S rt )r
index_urlsr s r? r" zPackageFinder.index_urls s ++rQ
str | Nonec $ | j j j S rt )r session pip_proxyr s r? proxyzPackageFinder.proxy s #+55rQ
Iterable[str]c # H K | j j j D ]
}t | V d S rt )r r% pip_trusted_originsr& )re host_ports r?
trusted_hostszPackageFinder.trusted_hosts s< -5I + +I * * * * * + +rQ c V | j j j }t |t r|nd S rt )r r% verify
isinstancer8 )re r. s r? custom_certzPackageFinder.custom_cert s+
%-4#FC00:vvd:rQ c f | j j j }t |t r
J d |S )Nz"pip only supports PEM client certs)r r% certr/ r{ )re r2 s r? client_certzPackageFinder.client_cert s4 #+0 dE**PP,PPP* rQ r c | j j S rt r r r s r? r z PackageFinder.release_control s $44rQ r r c || j _ d S rt r5 )re r s r? set_release_controlz!PackageFinder.set_release_control s 0? ---rQ c | j j S rt r r r s r? r zPackageFinder.prefer_binary s $22rQ c d| j _ d S )NTr9 r s r? set_prefer_binaryz PackageFinder.set_prefer_binary s .2 +++rQ c | j S rt )rd r s r? r[ z PackageFinder.uploaded_prior_to s &&rQ c B d | j D }t | S )Nc : h | ]\ }}}|t j k |S r, )rB rN )rx r resultdetails r? z@PackageFinder.requires_python_skipped_reasons.. s6
!66:::
:::rQ )r r )re reasonss r? requires_python_skipped_reasonsz-PackageFinder.requires_python_skipped_reasons s1
%)%7
g rQ rT r8 rS c t | }| j | }t |||| j | j | j | j S )N)rT rU rV rX rY r0 r[ )r r
get_allowed_formatsrS rc r_ ra rd )re rT rU rV s r? make_link_evaluatorz!PackageFinder.make_link_evaluator s] *<88%99.II %) - +#'#? " 5
rQ linksIterable[Link]
list[Link]c g g }}t }|D ]M}||vrG| | |j r| | 8| | N||z S )z
Returns elements of links in order, non-egg links first, egg links
second, while eliminating duplicates
)r addr r )re rG eggsno_eggsseenr- s r? _sort_linkszPackageFinder._sort_links s|
Bg %% ) )D4 $ )KK%%%%NN4(((~ rQ r- r r? rB r@ c |||f}|| j vr8t d|| | j | d S d S )NzSkipping link: %s: %s)r r9 r; rK )re r- r? r@ entrys r? _log_skipped_linkz PackageFinder._log_skipped_link, sZ vv& * * *
LL0&$ ? ? ? " "5 ) ) ) ) ) + *rQ link_evaluatorr c | | \ }}|t j k rt | |t j k r| ||| dS t
|j || S # t $ r Y dS w xY w)z
If the link is a candidate for install, convert it to an
InstallationCandidate and return it. Otherwise, return None.
N)r r- r> ) r rB rP r rH rR r rT r
)re rS r- r? r@ s r? get_install_candidatez#PackageFinder.get_install_candidate4 s (55d;; X1 1 1 $F++ + X' ' ' " "4 8 8 84 (#0
44 s "A9 9
BBr c g }| | D ]/}| || }|| | 0|S )zU
Convert links that are candidates to InstallationCandidate objects.
)rO rU r )re rS rG r r- rH s r? evaluate_linksz PackageFinder.evaluate_linksM s\
$$U++ - -D 22>4HHI$!!),,,rQ project_urlc * t d| | j | }|g S t t | }t
5 | || }d d d n # 1 swxY w Y |S )Nz-Fetching project page and analyzing links: %s)rG )r9 r; r fetch_responser r r% rW )re rX rS index_response
page_links
package_linkss r? process_project_urlz!PackageFinder.process_project_url[ s ;
-<<[II !I+n5566
\\ / / 0 M s $BB B c r || j v r
| j | S | | }| j |t j | j | }t j d |D }t | }t j d |D }| |t |d }t t j r|rg }|D ]_} | j j sJ | | j j 1# t* $ r" | | j j Y \w xY wt dd | ||z | j |< | j | S ) a Find all available InstallationCandidate for project_name
This checks index_urls and find_links.
All versions found are returned as an InstallationCandidate list.
See LinkEvaluator.evaluate_link() for details on which files
are accepted.
)rS )rT candidates_from_pagec 3 L K | ] }|D ]}|| V d S rt )page_candidatesrx sourcesrn s r? rz z4PackageFinder.find_all_candidates.. sW ;
;
!;
;
!
" " $ $ "!!!! ;
;
rQ c 3 L K | ] }|D ]}|| V d S rt )
file_linksrc s r? rz z4PackageFinder.find_all_candidates.. sW 6
6
!6
6
!
"!!!! 6
6
rQ T)reversezLocal files found: %srl )r rF r collect_sources functoolspartialr^ itertoolschain
from_iterabler rW r r9 isEnabledForloggingDEBUGr- urlr file_path Exceptionr; r6 )
re rT rS collected_sourcespage_candidates_itrb
file_links_itfile_candidatespathsrH s
r? find_all_candidatesz!PackageFinder.find_all_candidatesp s 4/ / /' 5 5 11,?? 0 @ @%!*!2( -" " " A
'_ : : ;
;
,;
;
;
122!55 6
6
,6
6
6
-- =$ / / /
w} - - D/ DE ,
5
5 ~))))5LL !9:::: 5 5 5LL !3444445
LL0$))E2B2B C C C .=-N \*#L11s " E)E.-E.r r r r r c n | j }t || j |j |j || S )z*Create a CandidateEvaluator object to use.)rT rX r r r r )r r r rc r r )re rT r r r s r? make_candidate_evaluatorz&PackageFinder.make_candidate_evaluator sD /!((% -)7 + ;
)
rQ r* c |||f| j v r| j |||f S | | }| ||| }| | | j |||f< | j |||f S )a Find matches for the given project and specifier.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:return: A `BestCandidateResult` instance.
)rT r r )r ry r{ r )re rT r r r candidate_evaluators r? find_best_candidatez!PackageFinder.find_best_candidate s
)V ,0E E E( y&)HI I--l;;
" ; ;% <
6 6z B B
lIv => $\9f%DEErQ reqr! upgradec D
|j }|
J d | d }| ||j | }|j
d |j |j j dd
} u
sd }| j -| j t | }|du rd }t d
|| ||j t d| d
fd } |sL J |
r"t d
j nt d dS |
r1t d
j ||j
S t d ||j t )zTry to find a Link matching req
Expects req, an InstallRequirement and upgrade, a boolean
Returns a InstallationCandidate if found,
Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
Nz&find_requirement() called with no nameF)trust_internet)r r cand_iter Iterable[InstallationCandidate]r2 r8 c l d t d | D t pdS )Nrl c 6 h | ]}t |j S r, r r s r? rA zKPackageFinder.find_requirement.._format_versions.. s ;;;AQY ;;;rQ r none)r6 r
parse_version)r s r? _format_versionsz8PackageFinder.find_requirement.._format_versions sJ ;;;;; )
rQ r> z
final versionzICould not find a %s that satisfies the requirement %s (from versions: %s)z#No matching distribution found for rH r TypeGuard[InstallationCandidate]c * dS dS j k S )NTFr )rH r installed_versions r? _should_install_candidatezAPackageFinder.find_requirement.._should_install_candidate s* !(t % u!),== =rQ zUExisting installed version (%s) satisfies requirement (most up-to-date version is %s)zLExisting installed version (%s) is most up-to-date and satisfies requirementz)Using version %s (newest of versions: %s)z=Installed version (%s) is most up-to-date (past versions: %s))r r r2 r8 )rH r r2 r )r r r~ r r satisfied_byr> r r r r9 criticalr r r; r r ) re r r r r best_candidate_resultr version_type
allows_prer r r s @@r? find_requirementz PackageFinder.find_requirement sJ x !I 511 $ 8 8 m !9 !
!
/=15 ' # 0 8
$ )?$L#/ ! 1 D D%d++
&L OO& !6!EFF
''RS'R'RSS S > > > > > > > ,8(( 88
6%"* ,%
4 $ $^ 4 4 " LL; & !6!LMM
" ! K 2 H I I
*)rQ )NNNN)r r rX r rY r1 r
r r r r0 rZ r[ r\ r2 r] r )
r r r r rX r r[ r\ r2 r+ )r2 r )r2 r )r r r2 r] )r2 r )r2 r# )r2 r( )r2 r )r r r2 r] )r2 r1 r )r2 r\ )rT r8 r2 rS )rG rH r2 rI )r- r r? rB r@ r8 r2 r] )rS rS r- r r2 r )rS rS rG rH r2 r )rX r rS rS r2 r )rT r8 r2 r )rT r8 r r r r r2 r )rT r8 r r r r r2 r* )r r! r r1 r2 r )!rC rD rE r rf r
r propertyrX r setterr r" r' r, r0 r3 r r7 r r; r[ rC rF rO rR rU rW r^ ry r{ r~ r r, rQ r? r+ r+ n s& 047;.26:* * * * *`
.26: !
!
!
!
[!
F # # # X# 1 1 1 X1 9 9 9 9 / / / X/ , , , X, 6 6 6 X6 + + + X+ ; ; ; X; X
5 5 5 X5@ @ @ @ 3 3 3 X33 3 3 3 ' ' ' X'
* * * * 2 *72 72 72 72x 6: $
( 6: $ F F F F F:b* b* b* b* b* b*rQ r+ fragmentrU rv c t | D ]+\ }}|dk r t | d| |k r|c S ,t | d| )a Find the separator's index based on the package's canonical name.
:param fragment: A + filename "fragment" (stem) or
egg fragment.
:param canonical_name: The package's canonical name.
This function is needed since the canonicalized name does not necessarily
have the same length as the egg info's name part. An example::
>>> fragment = 'foo__bar-1.0'
>>> canonical_name = 'foo-bar'
>>> _find_name_version_sep(fragment, canonical_name)
8
-Nz does not match )r r r )r rU ir s r? _find_name_version_sepr < sp $ (## 1 88 Xbqb\ * *n < <HHH =
BB.BB
C
CCrQ r# c n t | | dz }n# t $ r Y dS w xY w| |d }|sdS |S )zParse the version string from a + filename
"fragment" (stem) or egg fragment.
:param fragment: The string to parse. E.g. foo-2.1
:param canonical_name: The canonicalized name of the package this
belongs to.
ro N)r r )r rU
version_startr> s r? r r V s_ .x HH1L
tt}~~&G t Ns
$$)F)r- r r. r/ r0 r1 r2 r1 )r r r r rT r8 r2 r )r r8 rU r8 r2 rv )r r8 rU r8 r2 r# )^r
__future__r datetimerF ri rk ro r collections.abcr dataclassesr typingr r r pip._vendor.packagingr pip._vendor.packaging.tagsr
pip._vendor.packaging.utilsr r pip._vendor.packaging.versionr
r r r r pip._internal.exceptionsr r r r r pip._internal.index.collectorr r pip._internal.metadatar pip._internal.models.candidater #pip._internal.models.format_controlr pip._internal.models.linkr $pip._internal.models.release_controlr !pip._internal.models.search_scoper $pip._internal.models.selection_prefsr "pip._internal.models.target_pythonr pip._internal.models.wheelr pip._internal.reqr! pip._internal.utils._logr" pip._internal.utils.filetypesr# pip._internal.utils.hashesr$ pip._internal.utils.loggingr% pip._internal.utils.miscr& pip._internal.utils.packagingr' pip._internal.utils.unpackingr( typing_extensionsr) __all__rC r9 r{ rv r8 BuildTagr r@ EnumrB rS r r r* r r+ r r r, rQ r? r s ' ' " " " " " " $ $ $ $ $ $ ! ! ! ! ! ! - , , , , , * * * * * * I I I I I I I I O O O O O O O O O O @ @ @ @ @ @ E D D D D D D D 1 1 1 1 1 1 @ @ @ @ @ @ = = = = = = * * * * * * ? ? ? ? ? ? 9 9 9 9 9 9 E E E E E E ; ; ; ; ; ; , , , , , , 0 0 0 0 0 0 . . . . . . 9 9 9 9 9 9 - - - - - - 2 2 2 2 2 2 1 1 1 1 1 1 ? ? ? ? ? ? > > > > > > ,++++++
C
C
C
8 rE#s(O+ ,Cc<# PQ $), , , , ,^ & & & & &ty & & &q- q- q- q- q- q- q- q-hG G G GT 2 2 2 2 2 2 2 2 $E E E E E E E E2N
N
N
N
N
N
N
N
bK* K* K* K* K* K* K* K*\D D D D4 rQ PK ! FX5 X5 # __pycache__/sources.cpython-311.pycnu [
i! d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m Z m
Z
mZmZmZ d dlmZ d dlmZ d d lmZmZ d d
lmZ ej e Z ee Z ee Z e
egee f Z e
ege f Z! G d d Z"d&dZ# G d d Z$ G d de" Z% G d de" Z& G d de" Z' G d de" Z(d'd%Z)dS )( ) annotationsN) defaultdict)Iterable)Callable)InvalidSdistFilenameInvalidWheelFilenamecanonicalize_nameparse_sdist_filenameparse_wheel_filename)InstallationCandidate)Link) path_to_url url_to_path)is_urlc 6 e Zd Zed d Zd
dZd dZdS )
LinkSourcereturn Link | Nonec t )z,Returns the underlying link, if there's one.NotImplementedErrorselfs {/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/pip/_internal/index/sources.pylinkzLinkSource.link s "### FoundCandidatesc t )z9Candidates found by parsing an archive listing HTML file.r r s r page_candidateszLinkSource.page_candidates% !###r
FoundLinksc t )z,Links found by specifying archives directly.r r s r
file_linkszLinkSource.file_links) r r Nr r r r r r! )__name__
__module__ __qualname__propertyr r r# r r r r sZ
$ $ $ X$$ $ $ $$ $ $ $ $ $r r file_urlstrr boolc B t j | d d dk S )NF)strictr z text/html) mimetypes
guess_type)r, s r
_is_html_filer3 . s" 7 7 7 :k IIr c R e Zd ZdZd
dZddZedd Zedd Zd S )_FlatDirectoryToUrlsz"Scans directory and caches resultspathr- r Nonec b || _ g | _ t t | _ d| _ d S )NF)_path_page_candidatesr list_project_name_to_urls_scanned_directory)r r6 s r __init__z _FlatDirectoryToUrls.__init__5 s/
+- ;Ft;L;L""' r c t j | j D ]}t |j }t | r| j | @ t |j d }n=# t $ r0 t |j d }n# t $ r Y Y w xY wY nw xY w| j
| | d| _ dS )zrScans directory once and populates both page_candidates
and project_name_to_urls at the same time
r TN)osscandirr9 r r6 r3 r: appendr namer r
r r< r= )r entryurlproject_filenames r _scan_directoryz$_FlatDirectoryToUrls._scan_directory; s Z
++ E EE ej))C S!!
%,,S111
#7
#C#CA#F '
';EJ'G'G'J$$+ HH %$
&'7 8 ? ? D D D D"& s6 A66
B0B B0
B*&B0)B**B0/B0 list[str]c F | j s| | j S N)r= rG r: r s r r z$_FlatDirectoryToUrls.page_candidatesR s( & # " " "$$r dict[str, list[str]]c F | j s| | j S rJ )r= rG r< r s r project_name_to_urlsz)_FlatDirectoryToUrls.project_name_to_urlsY s( & # " " "))r N)r6 r- r r7 )r r7 )r rH )r rK ) r' r( r) __doc__r> rG r* r rM r+ r r r5 r5 2 s ,,( ( ( ( ' ' ' '. % % % X% * * * X* * *r r5 c R e Zd ZU dZi Zded< dd Zedd
ZddZ ddZ
dS )_FlatDirectorySourcezLink source specified by ``--find-links=``.
This looks the content of the directory, and returns:
* ``page_candidates``: Links listed on each HTML file in the directory.
* ``file_candidates``: Archives in the directory.
z dict[str, _FlatDirectoryToUrls]_paths_to_urlscandidates_from_pageCandidatesFromPager6 r- project_namer r7 c || _ t | | _ || j v r| j | | _ d S t | | _ | j | j |< d S )N)r6 )_candidates_from_pager
_project_namerQ
_path_to_urlsr5 )r rR r6 rT s r r> z _FlatDirectorySource.__init__l sk &:" .| < < 4& & &!%!4T!:D !54!@!@!@D (,(:D % % %r r c d S rJ r+ r s r r z_FlatDirectorySource.link| s tr r c # x K | j j D ]*}| t | E d {V +d S rJ )rX r rV r
r rE s r r z$_FlatDirectorySource.page_candidates sT %5 = =C11$s))<< < < < < < < < < = =r r! c # ` K | j j | j D ]}t | V d S rJ )rX rM rW r
r[ s r r# z _FlatDirectorySource.file_links s> %:4;MN Cs))OOOO r N)rR rS r6 r- rT r- r r7 r$ r% r& ) r' r( r) rN rQ __annotations__r> r* r r r# r+ r r rP rP a s 79N8888; ; ; ; X= = = = r rP c B e Zd ZdZddZedd
Zdd ZddZdS )_LocalFileSourceaC ``--find-links=`` or ``--[extra-]index-url=``.
If a URL is supplied, it must be a ``file:`` URL. If a path is supplied to
the option, it is converted to a URL first. This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
rR rS r r
r r7 c " || _ || _ d S rJ rV _linkr rR r s r r> z_LocalFileSource.__init__
&:"
r r c | j S rJ rb r s r r z_LocalFileSource.link
zr r c # K t | j j sd S | | j E d {V d S rJ )r3 rb rE rV r s r r z _LocalFileSource.page_candidates sM TZ^,, F--dj99999999999r r! c # R K t | j j rd S | j V d S rJ )r3 rb rE r s r r# z_LocalFileSource.file_links s3 ( ( Fjr NrR rS r r
r r7 r$ r% r& r' r( r) rN r> r* r r r# r+ r r r_ r_ sz X: : : :
r r_ c B e Zd ZdZdd
Zedd ZddZddZdS )_RemoteFileSourcez``--find-links=`` or ``--[extra-]index-url=``.
This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
rR rS page_validator
PageValidatorr r
r r7 c 0 || _ || _ || _ d S rJ )rV _page_validatorrb )r rR rn r s r r> z_RemoteFileSource.__init__ s &:" -
r r c | j S rJ rf r s r r z_RemoteFileSource.link rg r r c # K | | j sd S | | j E d {V d S rJ )rq rb rV r s r r z!_RemoteFileSource.page_candidates sQ ##DJ// F--dj99999999999r r! c # K | j V d S rJ rf r s r r# z _RemoteFileSource.file_links s jr N)rR rS rn ro r r
r r7 r$ r% r& rk r+ r r rm rm sz X: : : :
r rm c B e Zd ZdZddZedd
Zdd ZddZdS )_IndexDirectorySourcez``--[extra-]index-url=``.
This is treated like a remote URL; ``candidates_from_page`` contains logic
for this by appending ``index.html`` to the link.
rR rS r r
r r7 c " || _ || _ d S rJ ra rc s r r> z _IndexDirectorySource.__init__ rd r r c | j S rJ rf r s r r z_IndexDirectorySource.link rg r r c # J K | | j E d {V d S rJ ra r s r r z%_IndexDirectorySource.page_candidates s4 --dj99999999999r r! c dS )Nr+ r+ r s r r# z _IndexDirectorySource.file_links s rr Nrj r$ r% r& rk r+ r r rv rv sz X: : : : r rv locationrR rS rn ro
expand_dircache_link_parsingrT $tuple[str | None, LinkSource | None]c d }d }t j | rt | }| }n8| d r| }t | }nt
| r| }| d}t || dS |%t ||t || } || fS t j | r9|rt ||| } n t |t || } || fS t j | r$t |t || } || fS t d| |d fS ) Nzfile:zVLocation '%s' is ignored: it is either a non-existing path or lacks a specific scheme.)NN)r} )rR rn r )rR r6 rT )rR r z?Location '%s' is ignored: it is neither a file nor a directory.)r@ r6 existsr
startswithr r loggerwarningrm r
isdirrP rv isfiler_ )
r{ rR rn r| r} rT r6 rE msgsources
r build_sourcer s DC w~~h (## W % % 8$$
{
K sH%%%| | .!5)c.@AAA
V} w}}T
)%9 ) FF +%9#2DEEE F V} !!5c.@AAA
V}
NNI
;r )r, r- r r. )r{ r- rR rS rn ro r| r. r} r. rT r- r r~ )*
__future__r loggingr1 r@ collectionsr collections.abcr typingr pip._vendor.packaging.utilsr r r r
r pip._internal.models.candidater pip._internal.models.linkr
pip._internal.utils.urlsr r pip._internal.vcsr getLoggerr' r r r! rS r. ro r r3 r5 rP r_ rm rv r r+ r r r s " " " " " " # # # # # # $ $ $ $ $ $ A @ @ @ @ @ * * * * * * = = = = = = = = $ $ $ $ $ $ 8 $ $01
d^
tfh/D&E EF $ &
$ $ $ $ $ $ $ $ J J J J,* ,* ,* ,* ,* ,* ,* ,*^% % % % % : % % % P z B
@ J 4; ; ; ; ; ;r PK ! #] ] % __pycache__/collector.cpython-311.pycnu [
i? d Z ddlmZ ddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl
mZmZmZ ddlmZ ddlmZ ddlmZ ddlmZmZmZ dd lm Z dd
l m Z dd l m Z m!Z! dd l"m#Z# dd
l$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6m7Z7 e j8 e9 Z:ee;e;f Z Z?dKd!Z@ G d" d#e> ZAdLd&ZBdMd'ZCdNd*ZD G d+ d, ZE G d- d.e ZFdOd0ZGeGdPd4 ZH ed56 G d7 d2 ZI G d8 d9e ZJ dQdRd@ZK dSdTdCZLdUdEZM G dF dGe ZN G dH dI ZOdS )VzO
The main purpose of this module is to expose LinkCollector.collect_sources().
) annotationsN)IterableMutableMappingSequence) dataclass)
HTMLParser)Values)Callable
NamedTupleProtocol)requests)Response)
RetryErrorSSLError)NetworkConnectionError)Link) SearchScope)
PipSession)raise_for_status)is_archive_fileredact_auth_from_url) url_to_path)vcs )CandidatesFromPage
LinkSource build_sourceurlstrreturn
str | Nonec t j D ]D}| | r| t | dv r|c S EdS )zgLook for VCS schemes in the URL.
Returns the matched VCS scheme, or None if there's no match.
z+:N)r schemeslower
startswithlen)r schemes }/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/pip/_internal/index/collector.py_match_vcs_schemer* . sW
+ 99;; ! !& ) ) c#f++.>$.F.FMMM 4 c e Zd Zd fd Z xZS )_NotAPIContent content_typer request_descr! Nonec h t || || _ || _ d S N)super__init__r. r/ )selfr. r/ __class__s r) r4 z_NotAPIContent.__init__: s3
|444 ( (r+ )r. r r/ r r! r0 )__name__
__module__ __qualname__r4
__classcell__r6 s @r) r- r- 9 s= ) ) ) ) ) ) ) ) ) )r+ r- responser r0 c | j dd }| }| d rdS t || j j )z
Check the Content-Type header to ensure the response contains a Simple
API Response.
Raises `_NotAPIContent` if the content type is not a valid content-type.
Content-TypeUnknown)z text/htmlz#application/vnd.pypi.simple.v1+html#application/vnd.pypi.simple.v1+jsonN)headersgetr% r& r- requestmethod)r< r. content_type_ls r) _ensure_api_headerrF @ sg #'' BBL!''))N
x'7'>
?
??r+ c e Zd ZdS )_NotHTTPN)r7 r8 r9 r+ r) rH rH V s Dr+ rH sessionr c t j | \ }}}}}|dvrt | | d }t | t
| dS )z
Send a HEAD request to the URL, and ensure the response contains a simple
API Response.
Raises `_NotHTTP` if the URL is not available for a HEAD request, or
`_NotAPIContent` if the content type is not a valid content type.
> httphttpsT)allow_redirectsN)urllibparseurlsplitrH headr rF )r rJ r( netlocpathqueryfragmentresps r) _ensure_api_responserX Z sq -3L,A,A#,F,F)FFD%
&&&jj <<T< 2 2DTt r+ c t t | j rt | | t dt
| | | d g d dd }t | t | t dt
| |j d d
|S ) aY Access an Simple API response with GET, and return the response.
This consists of three parts:
1. If the URL looks suspiciously like an archive, send a HEAD first to
check the Content-Type is HTML or Simple API, to avoid downloading a
large file. Raise `_NotHTTP` if the content type cannot be determined, or
`_NotAPIContent` if it is not HTML or a Simple API.
2. Actually perform the request. Raise HTTP exceptions on network failures.
3. Check the Content-Type header to make sure we got a Simple API response,
and raise `_NotAPIContent` otherwise.
rJ zGetting page %sz, )r@ z*application/vnd.pypi.simple.v1+html; q=0.1ztext/html; q=0.01z max-age=0)Acceptz
Cache-Control)rA zFetched page %s as %sr> r? ) r r filenamerX loggerdebugr rB joinr rF rA )r rJ rW s r) _get_simple_responser` l s tCyy)** 3 S'2222
LL"$8$=$=>>> ;; ii ( )+
D4 T t
LL S!! 33 Kr+ rA ResponseHeadersc | rSd| v rOt j }| d |d< | d }|rt | S dS )z=Determine if we have any encoding information in our headers.r> z content-typecharsetN)emailmessageMessage get_paramr )rA mrc s r) _get_encoding_from_headersri s` >W,, M ! ! # # #N 3.++i(( w<< 4r+ c & e Zd Zd
dZdd Zdd Zd S )CacheablePageContentpage IndexContentr! r0 c & |j sJ || _ d S r2 )cache_link_parsingrl r5 rl s r) r4 z CacheablePageContent.__init__ s &&&& r+ otherobjectboolc p t |t | o| j j |j j k S r2 )
isinstancetyperl r )r5 rq s r) __eq__zCacheablePageContent.__eq__ s* %d,,P %*.1PPr+ intc 4 t | j j S r2 )hashrl r r5 s r) __hash__z CacheablePageContent.__hash__ s DIM"""r+ N)rl rm r! r0 )rq rr r! rs )r! rx )r7 r8 r9 r4 rw r| rI r+ r) rk rk sT Q Q Q Q# # # # # #r+ rk c e Zd ZddZdS )
ParseLinksrl rm r! Iterable[Link]c d S r2 rI rp s r) __call__zParseLinks.__call__ s r+ Nrl rm r! r )r7 r8 r9 r rI r+ r) r~ r~ s AAAAAAr+ r~ fnc | t j d fd t j d
fd }|S ) z
Given a function that parses an Iterable[Link] from an IndexContent, cache the
function's result (keyed by CacheablePageContent), unless the IndexContent
`page` has `page.cache_link_parsing == False`.
cacheable_pagerk r!
list[Link]c > t | j S r2 )listrl )r r s r) wrapperz*with_cached_index_content..wrapper s BB~*++,,,r+ rl rm c r | j r t | S t | S r2 )ro rk r )rl r r s r) wrapper_wrapperz2with_cached_index_content..wrapper_wrapper s; " 77/5566 6BBtHH~~ r+ )r rk r! r )rl rm r! r ) functoolscachewraps)r r r s ` @r) with_cached_index_contentr sr _- - - - - _- _R
r+ rl rm r c # K | j }| d rUt j | j }| dg D ]#}t j || j }| |V $dS t | j }| j pd}| | j
| | j }|j p|}|j D ] } t j | || }| |V !dS )z\
Parse a Simple API's Index Content, and yield its anchor elements as Link objects.
r@ filesNzutf-8)page_urlbase_url)r. r% r& jsonloadscontentrB r from_jsonr HTMLLinkParserencodingfeeddecoder anchors from_element)
rl rE datafilelinkparserr r r anchors
r) parse_linksr s! &,,..N !FGG z$,''HHWb)) D>$11D|JJJJ
DH
%
%F}'H
KK ##H--...
(C%#H. #III <
r+ T)frozenc R e Zd ZU dZded< ded< ded< ded< d Zd
ed < dd
ZdS )rm a Represents one response (or page), along with its URL.
:param encoding: the encoding to decode the given content.
:param url: the URL from which the HTML was downloaded.
:param cache_link_parsing: whether links parsed from this page's url
should be cached. PyPI index urls should
have this set to False, for example.
bytesr r r. r" r r Trs ro r! c * t | j S r2 )r r r{ s r) __str__zIndexContent.__str__ s #DH---r+ N)r! r )r7 r8 r9 __doc____annotations__ro r rI r+ r) rm rm sr NNN HHH #####. . . . . .r+ c 4 e Zd ZdZd
fd Zdd
Zdd Z xZS )r zf
HTMLParser that keeps the first base HREF and a list of all anchor
elements' attributes.
r r r! r0 c v t d || _ d | _ g | _ d S )NT)convert_charrefs)r3 r4 r r r )r5 r r6 s r) r4 zHTMLLinkParser.__init__ s7
$///$(
46 r+ tagattrs list[tuple[str, str | None]]c |dk r)| j "| | }| || _ d S d S |dk r)| j t | d S d S )Nbasea)r get_hrefr appenddict)r5 r r hrefs r) handle_starttagz HTMLLinkParser.handle_starttag sn &==T] 2==''D $
CZZ L U , , , , , Zr+ r" c * |D ]\ }}|dk r|c S d S )Nr rI )r5 r namevalues r) r zHTMLLinkParser.get_href! s1 KD%v~~ tr+ )r r r! r0 )r r r r r! r0 )r r r! r" )r7 r8 r9 r r4 r r r: r; s @r) r r so
7 7 7 7 7 7- - - - r+ r r r reasonstr | ExceptionmethCallable[..., None] | Nonec < | t j } |d| | d S )Nz%Could not fetch URL %s: %s - skipping)r] r^ )r r r s r) _handle_get_simple_failr ( s+
||D 0$?????r+ ro rs c | t | j }t | j | j d || j | S )Nr> )r r ro )ri rA rm r r )r< ro r s r) _make_index_contentr 2 sG *(*:;;H ( L- r+ IndexContent | Nonec | j dd d }t | }|r t d|| d S | d rt j t | rU|
d s|dz
}t j
|d }t d| t || }t! || j
S # t$ $ r t d | Y n
t& $ r1}t d | |j |j Y d }~nd }~wt, $ r}t/ | | Y d }~nd }~wt0 $ r}t/ | | Y d }~nd }~wt2 $ r:}d
}|t5 | z
}t/ | |t j Y d }~nRd }~wt8 j $ r }t/ | d| Y d }~n(d }~wt8 j $ r t/ | d Y nw xY wd S )N#r r zICannot look at %s URL %s because it does not support lookup as web pages.zfile:/z
index.htmlz# file: URL is directory, getting %srZ )ro z`Skipping page %s because it looks like an archive, and cannot be checked by a HTTP HEAD request.zSkipping page %s because the %s request got Content-Type: %s. The only supported Content-Types are application/vnd.pypi.simple.v1+json, application/vnd.pypi.simple.v1+html, and text/htmlz4There was a problem confirming the ssl certificate: )r zconnection error: z timed out) r splitr* r] warningr& osrT isdirr endswithrO rP urljoinr^ r` r ro rH r- r/ r. r r r r r infor
ConnectionErrorTimeout)r rJ r
vcs_schemerW excr s r) _get_index_contentr ? s
(..a
#C #3''J W
t ~~g
A27==S1A1A#B#B
A ||C 3JC
l""3 55 :C@@@ U#C999: #4Dz'LinkCollector.create.. s+ IIs-c22IIIIIIr+ )r r no_index)rJ r )
index_urlextra_index_urlsr r] r^ r_ r r creater )clsrJ r r r r r link_collectors r) r zLinkCollector.create s '(7+CC
$5 LL&IIjIIIII
J '-2
")!! %
'%
r+ list[str]c | j j S r2 )r r r{ s r) r zLinkCollector.find_links s ++r+ locationr r c . t || j S )z>
Fetch an HTML page containing package links.
rZ )r rJ )r5 r s r) fetch_responsez LinkCollector.fetch_response s "(DLAAAAr+ project_namer candidates_from_pager r c z t j fd j D }t j fd j D }t t j red t j || D }t | d dg|z }t
d | t t! | t! | S )Nc 3 V K | ]#}t |j j d d V $dS )Fr page_validator
expand_dirro r Nr rJ is_secure_originr locr r r5 s r) r z0LinkCollector.collect_sources.. s_
4
4
%9 #| < #( )
4
4
4
4
4
4
r+ c 3 V K | ]#}t |j j d d V $dS )Tr Nr r s r) r z0LinkCollector.collect_sources.. s_
5
5
%9 #| < #' )
5
5
5
5
5
5
r+ c 4 g | ]}||j d|j S )Nz* )r )r ss r)
z1LinkCollector.collect_sources.. s6 =QV%7 QV
%7%7%7r+ z' location(s) to search for versions of :
)r r ) collections OrderedDictr get_index_urls_locationsvaluesr r] isEnabledForloggingDEBUG itertoolschainr' r^ r_ r r )r5 r r index_url_sourcesfind_links_sourcesliness ``` r) collect_sourcesz LinkCollector.collect_sources s ( 3
4
4
4
4
4
4
(AA,OO
4
4
4
&(( ) 4
5
5
5
5
5
5
5
5
5
&(( w} - -
+ " );=NOO E u:: 3 3#/3 3 3 E
LL5)) * * * .// -..
r+ N)rJ r r r r! r0 )F)rJ r r r r rs r! r )r! r )r r r! r )r r r r r! r ) r7 r8 r9 r r4 classmethodr propertyr r r rI r+ r) r r s
#( [ B , , , X,B B B B ,
,
,
,
,
,
r+ r )r r r! r" )r< r r! r0 )r r rJ r r! r0 )r r rJ r r! r )rA ra r! r" )r r~ r! r~ r r2 )r r r r r r r! r0 )T)r< r ro rs r! rm )r r rJ r r! r )Pr
__future__r r
email.messagerd r r r r r urllib.parserO collections.abcr r r dataclassesr html.parserr optparser typingr
r r pip._vendorr
pip._vendor.requestsr pip._vendor.requests.exceptionsr r pip._internal.exceptionsr pip._internal.models.linkr !pip._internal.models.search_scoper pip._internal.network.sessionr pip._internal.network.utilsr pip._internal.utils.filetypesr pip._internal.utils.miscr pip._internal.utils.urlsr pip._internal.vcsr sourcesr r r getLoggerr7 r] r ra r* Exceptionr- rF rH rX r` ri rk r~ r r rm r r r r r r rI r+ r) r% s # " " " " " > > > > > > > > > > ! ! ! ! ! ! " " " " " " ! ) ) ) ) ) ) @ @ @ @ @ @ @ @ ; ; ; ; ; ; * * * * * * 9 9 9 9 9 9 4 4 4 4 4 4 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 0 0 0 0 0 0 ! ! ! ! ! ! A A A A A A A A A A 8 $ $ c* ) ) ) ) )Y ) ) )@ @ @ @, y $< < < <~ # # # # # # # #B B B B B B B B ( 8 $. . . . . . . .( Z > (,@ @ @ @ @ 48
9 9 9 9x, , , , ,z , , ,
h
h
h
h
h
h
h
h
h
h
r+ PK ! L) ) * __pycache__/package_finder.cpython-312.pycnu [
-r*j d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl
mZmZmZ ddlmZ ddlmZ dd lmZmZ dd
lmZmZ dd lmZ dd l m Z m Z m Z 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/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z; ddlm?Z? ddl@mAZA dd lBmCZC dd lDmEZE dd lFmGZG erdd lHmIZI g d ZJ e;eK ZLeeMd! eMeNeOf f ZPeMeNeNeNeeeN ePf ZQ d4 d5d"ZR G d# d$ej ZT G d% d& ZU d6d'ZVe G d( d) ZW e d*+ G d, d- ZX G d. d/ ZY G d0 d1 ZZd7d2Z[d8d3Z\y)9z!Routines related to PyPI, indexes ) annotationsN)Iterable) dataclass)
TYPE_CHECKINGOptionalUnion)
specifiers)Tag)NormalizedNamecanonicalize_name)InvalidVersion _BaseVersion)parse)BestVersionAlreadyInstalledDistributionNotFoundInstallationErrorInvalidWheelFilenameUnsupportedWheel)
LinkCollector parse_links)select_backend)InstallationCandidate)
FormatControl)Link)ReleaseControl) SearchScope)SelectionPreferences) TargetPython)Wheel)InstallRequirement) getLogger)WHEEL_EXTENSION)Hashes)
indent_log) build_netloc)check_requires_python)SUPPORTED_EXTENSIONS) TypeGuard)r BestCandidateResult
PackageFinder c x t | j | }|sfdj t t | }|s#t
j
d|| j | yt
j d|| j | y# t j $ r$ t
j d| j | Y yw xY w)aa
Return whether the given Python version is compatible with a link's
"Requires-Python" value.
:param version_info: A 3-tuple of ints representing the Python
major-minor-micro version to check.
:param ignore_requires_python: Whether to ignore the "Requires-Python"
value if the given Python version isn't compatible.
) version_info.z4Link requires a different Python (%s not in: %r): %sFzBIgnoring failed Requires-Python check (%s not in: %r) for link: %sz2Ignoring invalid Requires-Python (%r) for link: %sT)
r& requires_pythonjoinmapstrloggerverbosedebugr InvalidSpecifier)linkr- ignore_requires_python
is_compatibleversions Q/opt/hc_python/lib/python3.12/site-packages/pip/_internal/index/package_finder.py_check_link_requires_pythonr< ? s - %
hhs3 56G)J(( LLT$$
3 & &
@
0 3
s B 4B98B9c > e Zd Z ej Z ej Z ej Z ej Z ej Z ej Z
ej Z ej Z ej Z
y)LinkTypeN)__name__
__module__ __qualname__enumauto candidatedifferent_projectyankedformat_unsupportedformat_invalidplatform_mismatchrequires_python_mismatchupload_too_lateupload_time_missingr+ r; r> r> n s| I!
TYY[F" TYY[N! (tyy{ diikO#$))+rM r> c h e Zd ZdZ ej
d Z d ddZddZy)
LinkEvaluatorzD
Responsible for evaluating links for a particular project.
z-py([123]\.?[0-9]?)$Nc f || _ || _ || _ || _ || _ || _ || _ y)aB
:param project_name: The user supplied package name.
:param canonical_name: The canonical package name.
:param formats: The formats allowed for this package. Should be a set
with 'binary' or 'source' or both in it.
:param target_python: The target Python interpreter to use when
evaluating link compatibility. This is used, for example, to
check wheel compatibility, as well as when checking the Python
version, e.g. the Python version embedded in a link filename
(or egg fragment) and against an HTML link's optional PEP 503
"data-requires-python" attribute.
:param allow_yanked: Whether files marked as yanked (in the sense
of PEP 592) are permitted to be candidates for install.
:param ignore_requires_python: Whether to ignore incompatible
PEP 503 "data-requires-python" values in HTML links. Defaults
to False.
:param uploaded_prior_to: If set, only allow links uploaded prior to
the given datetime.
N)
_allow_yanked_canonical_name_ignore_requires_python_formats_target_python_uploaded_prior_to project_name)selfrW canonical_nameformats
target_python allow_yankedr8 uploaded_prior_tos r; __init__zLinkEvaluator.__init__ s; < * - '=$
+"3 (rM c F d}|j r1| j s%|j xs d}t j d| fS |j
r|j
}|j }ni|j \ }}|st j dfS |t vrt j d| fS d| j vr*|t k( r!d| j }t j |fS d|j v r|d k( rt j d
fS |t k( r t |j }|j$ | j& k7 r"d | j d
}t j( |fS | j* j- }|j/ | s7dj1 |j3 }d| d}t j4 |fS |j6 }| j8 |j: s|j< 3|j> rd|j> } nd} t j@ | dfS |j< | j8 k\ r,t jB d|j< d| j8 fS d| j vr*|t k7 r!d| j }t j |fS |stE || j& }|s!d| j }t j" |fS | jF jI | }
|
rO|d|
jK }|
jM d } | | j* jN k7 rt j4 dfS tQ || j* jR | jT } | sa|jV }
|
r:d"d }d j1 tY d t[ j\ |
D | }
| d |
}t j^ |fS t` jc d!|| t jd |fS # t $ r t j" d fcY S w xY w)#a
Determine whether a link is a candidate for installation.
:return: A tuple (result, detail), where *result* is an enum
representing whether the evaluation found a candidate, or the reason
why one is not found. If a candidate is found, *detail* will be the
candidate's version string; if one is not found, it contains the
reason the link fails to qualify.
Nz zyanked for reason: z
not a filez unsupported archive format: binaryzNo binaries permitted for macosx10z.zipz macosx10 onezinvalid wheel filenamezwrong project name (not ), znone of the wheel's tags (zB) are compatible (run pip debug --verbose to show compatible tags)zIndex Indexz' does not provide upload-time metadata.z Upload time z not prior to sourcezNo sources permitted for z Missing project version for zPython version is incorrect)r- r8 c D t d | j d D S )Nc 3 T K | ] }|j st | " y wN)isdigitint.0ss r; zLLinkEvaluator.evaluate_link..get_version_sort_key.. s M AQ s ((r. )tuplesplit)vs r; get_version_sort_keyz9LinkEvaluator.evaluate_link..get_version_sort_key s M MMMrM ,c 3 2 K | ] }t | y wri )r2 rl s r; ro z.LinkEvaluator.evaluate_link.. s R)QAQ)Qs keyz Requires-Python zFound link %s, version: %s)rr r2 returnztuple[int, ...])3 is_yankedrQ
yanked_reasonr> rF egg_fragmentextsplitextrG r' rT r" rW pathr filenamer rH namerR rE rU get_unsorted_tags supportedr0 get_formatted_file_tagsrI r: rV is_file upload_time
comes_fromrL rK _extract_version_from_fragment_py_version_researchstartgroup
py_versionr< py_version_inforS r/ sortedr SpecifierSetrJ r3 r5 rD )rX r7 r: reasonegg_infor| wheelsupported_tags file_tags
index_infomatchr supports_pythonr/ rs s r;
evaluate_linkzLinkEvaluator.evaluate_link s( >>$"4"4''9>F OO':6(%CD D ((H((C MMOMHc 33\BB.. //23%8 t}},1G5d6G6G5HI 33V<<TYY&3&= 33^DDo% !$-- 0E ::!5!55 78I8I7J! LF $ 6 6??!%!4!4!F!F!H ~6 !% %*G*G*I JI4YK @L M % 6 6?? --
" " .t|| '??#)$//):!;J!(J 00!l"IJ !!T%<%<< ,,"4#3#3"4 5 $ 7 7 8: 4== (SO-C01B1B0CDF //8 84$$G 3D4E4E3FGF ++V4 4##**73 o
.G Q JT 0 0 ; ;; ..1
6 ,,<<#'#?#?
" 2 2O N #&((R)@)@ )QR 0# y 1/1BCF 55v> > 14A""G,,u , //0 s P P P )FN)rW r2 rY r rZ zfrozenset[str]r[ r r\ boolr8 r r] datetime.datetime | Nonerx None)r7 r rx ztuple[LinkType, str]) r? r@ rA __doc__recompiler r^ r r+ rM r; rO rO z s| RZZ 78N (-6:%)%) '%) %)
$ %)
%) !%%) 4%)
%)N}-rM rO c
L |s+t j dt | | t | S g }g }d}| D ]V }|j }|j
sn*|j
| r|dz
}n|j | F|j | X |r|}n t | }t | t | k( rd} n1dj t | dj d |D } t j d t | ||j |t | |z
| |S )
a
Filter out candidates whose hashes aren't allowed, and return a new
list of candidates.
If at least one candidate has an allowed hash, then all candidates with
either an allowed hash or no hash specified are returned. Otherwise,
the given candidates are returned.
Including the candidates with no hash specified when there is a match
allows a warning to be logged if there is a more preferred candidate
with no hash specified. Returning all candidates in the case of no
matches lets pip report the hash of the candidate that would otherwise
have been installed (e.g. permitting the user to more easily update
their requirements file with the desired hash).
zJGiven no hashes to check %s links for project %r: discarding no candidatesr )hashesrf zdiscarding no candidatesz discarding {} non-matches:
{}z
c 3 F K | ] }t |j y wri )r2 r7 )rm rD s r; ro z*filter_unallowed_hashes..e s I[ INN+[s !zPChecked %s links for project %r against %s hashes (%s matches, %s no digest): %s) r3 r5 lenlistr7 has_hashis_hash_allowedappendformatr0 digest_count)
candidatesr rW matches_or_no_digest non_matches match_countrD r7 filtereddiscard_messages
r; filter_unallowed_hashesr , s, (
'
O
J KK ~~}}
!
!
!
0 1 K y ) ##I. '
#
8}J'4<CC KKI[I I
LL ) J !K/ OrM c . e Zd ZU dZdZded< dZded< y)CandidatePreferenceszk
Encapsulates some of the preferences for filtering and sorting
InstallationCandidate objects.
Fr
prefer_binaryNReleaseControl | Nonerelease_control)r? r@ rA r r __annotations__r r+ rM r; r r v s
M4 -1O*1rM r T)frozenc 8 e Zd ZU dZded< ded< ded< d dZy)
r) a A collection of candidates, returned by `PackageFinder.find_best_candidate`.
This class is only intended to be instantiated by CandidateEvaluator's
`compute_best_candidate()` method.
:param all_candidates: A sequence of all available candidates found.
:param applicable_candidates: The applicable candidates.
:param best_candidate: The most preferred candidate found, or None
if no applicable candidates were found.
list[InstallationCandidate]all_candidatesapplicable_candidates InstallationCandidate | Nonebest_candidatec t | j t | j k sJ | j | j rJ y | j | j v sJ y ri )setr r r rX s r;
__post_init__z!BestCandidateResult.__post_init__ s^ 4--.#d6I6I2JJJJ &11 111&&$*D*DD DDrM Nrx r )r? r@ rA r r r r+ rM r; r) r) s! 0/6600ErM r) c e Zd ZdZe d d
d Z d d dZ d
dZddZ ddZ ddZ
y)CandidateEvaluatorzm
Responsible for filtering and sorting candidates for installation based
on what tags are valid.
Nc |
t }|t j }|j } | |||||| S )a Create a CandidateEvaluator object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:param hashes: An optional collection of allowed hashes.
)rW r specifierr r r )r r r get_sorted_tags)clsrW r[ r r r r r s r; createzCandidateEvaluator.create sR ( (NM "//1I&668%) ' +
rM c || _ || _ || _ || _ || _ || _ t
| D ci c] \ }}||
c}}| _ yc c}}w )z
:param supported_tags: The PEP 425 tags supported by the target
Python in order of preference (most preferred first).
N)_release_control_hashes_prefer_binary
_project_name
_specifier_supported_tags enumerate_wheel_tag_preferences) rX rW r r r r r idxtags r; r^ zCandidateEvaluator.__init__ sc !0 + )# -
&/~%>'
%>cCH%>'
# '
s
Ac B | j /| j j t | j }nd}| j }|j ||d }t
t | | j | j }t || j S )zM
Return the applicable candidates from a list of candidates.
Nc r t j dk( rt | j S | j S )N
pkg_resources)r NAMEr2 r: )cs r; z>CandidateEvaluator.get_applicable_candidates.. s1 !#((O; AII YY rM ) prereleasesrw )r r rW rv ) r allows_prereleasesr r r filterr r r r _sort_key)rX r allow_prereleasesr r filtered_applicable_candidatess r; get_applicable_candidatesz,CandidateEvaluator.get_applicable_candidates s , $ 5 5 H H!$"4"45! !% OO !* 0 0 ) !1 !
*A 12<< ++*
& 4$..IIrM c | j }t | }d}d}|j }|j rNt |j
} |j
|| j }| j rd}|j }n| }t |j | j } dt |j z }
| |
||j ||fS # t $ r t |j
d w xY w)a)
Function to pass as the `key` argument to a call to sorted() to sort
InstallationCandidates by preference.
Returns a tuple such that tuples sorting as greater using Python's
default comparison operator are more preferred.
The preference is as follows:
First and foremost, candidates with allowed (matching) hashes are
always preferred over candidates without matching hashes. This is
because e.g. if the only candidate with an allowed hash is yanked,
we still want to use that candidate.
Second, excepting hash considerations, candidates that have been
yanked (in the sense of PEP 592) are always less preferred than
candidates that haven't been yanked. Then:
If not finding wheels, they are sorted by version only.
If finding wheels, then the sort order is by version, then:
1. existing installs
2. wheels ordered via Wheel.support_index_min(self._supported_tags)
3. source archives
If prefer_binary was set, then all wheels are sorted above sources.
Note: it was considered to embed this logic into the Link
comparison operators, but then different sdist links
with the same version, would have to be considered equal
r+ r z@ is not a supported wheel for this platform. It can't be sorted.rf )r r r7 is_wheelr r find_most_preferred_tagr
ValueErrorr r build_tagrk r r ry r: ) rX rD
valid_tags support_numr binary_preferencer7 r prihas_allowed_hash
yank_values r; r z CandidateEvaluator._sort_key s < ))
*o ~~ ==$--(E
11"D$?$? ""$%! I .C t 3 3DLL AB#dnn--
& ~~& '' '
s
C "C5c : |syt || j }|S )zy
Return the best candidate per the instance's sort order, or None if
no candidate is acceptable.
Nrv )maxr )rX r r s r; sort_best_candidatez&CandidateEvaluator.sort_best_candidateG s ZT^^< rM c b | j | }| j | }t ||| S )zF
Compute and return a `BestCandidateResult` instance.
)r r )r r r) )rX r r r s r; compute_best_candidatez)CandidateEvaluator.compute_best_candidateT s< !% > >z J 112GH" "7)
rM )NFNNN)rW r2 r[ TargetPython | Noner r r r r specifiers.BaseSpecifier | Noner
Hashes | Nonerx r )FNN)rW r2 r z list[Tag]r zspecifiers.BaseSpecifierr r r r r r rx r )r r rx r )rD r rx CandidateSortingKey)r r rx r )r r rx r) ) r? r@ rA r classmethodr r^ r r r r r+ rM r; r r s
.2 #1559 $!
!
+!
!
/ !
3
!
!
!
!
P $15 $
"
,
/
4%J/%J
%%JN?
B /
&
/
rM r c e Zd ZdZ d d dZe d d!d Zed"d Zed#d Z e j d$d Z ed%d Z ed%d Z ed&d
Z
ed'd Zed&d Zed&d
Zed(d Zd)dZed*d Zd+dZed,d Zd%dZd-dZd.dZd/dZ d0dZ d1dZ d2dZ d3dZ d d4dZ d d5d Z d6d Z y)7r* zThis finds packages.
This is meant to match easy_install's technique for looking for
packages, by reading pages and looking for appropriate links.
Nc |
t }|xs t t t }|| _ || _ || _ || _ || _ || _ || _ t | _
i | _ i | _ y)a
This constructor is primarily meant to be used by the create() class
method and from tests.
:param format_control: A FormatControl object, used to control
the selection of source packages / binary packages when consulting
the index and links.
:param candidate_prefs: Options to use when creating a
CandidateEvaluator object.
N)
r r r rQ _candidate_prefsrS _link_collectorrU rV format_control_requires_python_skipped_all_candidates_best_candidates)rX link_collectorr[ r\ r candidate_prefsr8 r] s r; r^ zPackageFinder.__init__m s ( " 2 4O'F=+F ) / '=$ - +"3 ,
36%% HJ
rM c |
t }t |j |j } | ||||j |j
|j | S )a Create a PackageFinder.
:param selection_prefs: The candidate selection preferences, as a
SelectionPreferences object.
:param target_python: The target Python interpreter to use when
checking compatibility. If None (the default), a TargetPython
object will be constructed from the running Python.
:param uploaded_prior_to: If set, only find links uploaded prior
to the given datetime.
)r r )r r r[ r\ r r8 r] )r r r r r\ r r8 )r r selection_prefsr[ r] r s r; r zPackageFinder.create sc $ (NM.)77 + ; ;
+)'(55*99#2#I#I /
rM c | j S ri )rU r s r; r[ zPackageFinder.target_python s """rM c . | j j S ri r search_scoper s r; r zPackageFinder.search_scope s ##000rM c & || j _ y ri r )rX r s r; r zPackageFinder.search_scope s ,8 )rM c . | j j S ri )r
find_linksr s r; r zPackageFinder.find_links s ##...rM c . | j j S ri )r
index_urlsr s r; r zPackageFinder.index_urls s +++rM c B | j j j S ri )r session pip_proxyr s r; proxyzPackageFinder.proxy s ##++555rM c # j K | j j j D ] }t | y wri )r r
pip_trusted_originsr% )rX host_ports r;
trusted_hostszPackageFinder.trusted_hosts s. --55III * * Js 13c j | j j j }t |t r|S d S ri )r r
verify
isinstancer2 )rX r s r; custom_certzPackageFinder.custom_cert s/
%%--44#FC0v:d:rM c t | j j j }t |t rJ d |S )Nz"pip only supports PEM client certs)r r
certr rp )rX r s r; client_certzPackageFinder.client_cert s4 ##++00 dE*P,PP* rM c . | j j S ri r r r s r; r z PackageFinder.release_control s $$444rM c & || j _ y ri r )rX r s r; set_release_controlz!PackageFinder.set_release_control s 0? -rM c . | j j S ri r r r s r; r zPackageFinder.prefer_binary s $$222rM c & d| j _ y )NTr r s r; set_prefer_binaryz PackageFinder.set_prefer_binary s .2 +rM c | j S ri )rV r s r; r] z PackageFinder.uploaded_prior_to s &&&rM c , t | j S ri )r r r s r; requires_python_skipped_reasonsz-PackageFinder.requires_python_skipped_reasons s d3344rM c t | }| j j | }t |||| j | j
| j | j S )N)rW rY rZ r[ r\ r8 r] )r r get_allowed_formatsrO rU rQ rS rV )rX rW rY rZ s r; make_link_evaluatorz!PackageFinder.make_link_evaluator s\ *<8%%99.I %) -- ++#'#?#? " 5 5
rM c g g }}t }|D ]G }||vs|j | |j r|j | 7|j | I ||z S )z
Returns elements of links in order, non-egg links first, egg links
second, while eliminating duplicates
)r addr{ r )rX linkseggsno_eggsseenr7 s r; _sort_linkszPackageFinder._sort_links s^
Bg %D4 $$KK%NN4(
~ rM c t j d|| |t j k( r | j j | y y )NzSkipping link: %s: %s)r3 r5 r> rJ r r* )rX r7 resultdetails r; _log_skipped_linkz PackageFinder._log_skipped_link! s< ,fd; X66 6 ) ) - -f 5 7rM c |j | \ }}|t j k( r t | |t j k7 r| j ||| y t
|j || S # t $ r Y yw xY w)z
If the link is a candidate for install, convert it to an
InstallationCandidate and return it. Otherwise, return None.
N)r r7 r: ) r r> rL r rD r3 r rW r
)rX link_evaluatorr7 r1 r2 s r; get_install_candidatez#PackageFinder.get_install_candidate( s (55d; X11 1 $F+ + X'' ' " "4 8 (#00
s A3 3 A?>A?c g }| j | D ]( }| j || }||j | * |S )zU
Convert links that are candidates to InstallationCandidate objects.
)r/ r6 r )rX r5 r+ r r7 rD s r; evaluate_linksz PackageFinder.evaluate_linksA sL
$$U+D 22>4HI$!!), ,
rM c t j d| | j j | }|g S t t | }t
5 | j || }d d d |S # 1 sw Y S xY w)Nz-Fetching project page and analyzing links: %s)r+ )r3 r5 r fetch_responser r r$ r8 )rX project_urlr5 index_response
page_links
package_linkss r; process_project_urlz!PackageFinder.process_project_urlO s ;
--<<[I !I+n56
\ / / 0 M
s A22A<c || j v r| j | S | j | }| j j |t j
| j | }t j j d |D }t | }t j j d |D }| j |t |d }t j t j rn|rlg }|D ]@ } | j" j$ sJ |j' | j" j( B t j- ddj/ | ||z | j |< | j | S # t* $ r( |j' | j" j$ Y w xY w) a Find all available InstallationCandidate for project_name
This checks index_urls and find_links.
All versions found are returned as an InstallationCandidate list.
See LinkEvaluator.evaluate_link() for details on which files
are accepted.
)r5 )rW candidates_from_pagec 3 N K | ] }|D ] }||j y wri )page_candidatesrm sourcesre s r; ro z4PackageFinder.find_all_candidates..z s4 ;
,!!
" " $!
%, #%c 3 N K | ] }|D ] }||j y wri )
file_linksrD s r; ro z4PackageFinder.find_all_candidates.. s4 6
,!!
!
,rF T)reversezLocal files found: %src )r r( r collect_sources functoolspartialr? itertoolschain
from_iterabler r8 r r3 isEnabledForloggingDEBUGr7 urlr file_path Exceptionr5 r0 )
rX rW r5 collected_sourcespage_candidates_itrC
file_links_itfile_candidatespathsrD s
r; find_all_candidatesz!PackageFinder.find_all_candidatesd s 4// /'' 5 5 11,? 0 0 @ @%!*!2!2(( -" A
'__ : : ;
,;
12!55 6
,6
-- =$ /
w}} -/E , ~~))))5LL !9!9: -
LL0$))E2B C .=-N \*##L11 ! 5LL !3!345s $%F.GGc | j }t j || j |j |j
|| S )z*Create a CandidateEvaluator object to use.)rW r[ r r r r )r r r rU r r )rX rW r r r s r; make_candidate_evaluatorz&PackageFinder.make_candidate_evaluator sK //!((% --)77 + ; ;
)
rM c |||f| j v r| j |||f S | j | }| j ||| }|j | | j |||f< | j |||f S )a Find matches for the given project and specifier.
:param specifier: An optional object implementing `filter`
(e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
versions.
:return: A `BestCandidateResult` instance.
)rW r r )r r[ r] r )rX rW r r r candidate_evaluators r; find_best_candidatez!PackageFinder.find_best_candidate s
)V ,0E0E E(( y&)HI I--l;
" ; ;% <
6 6z B
lIv => $$\9f%DEErM c L
|j }|J d |j d }| j ||j | }|j
d |j
|j
j dd} p
nd}| j *| j j t | }|du rd}t j d || ||j t d
| d
fd } |sC A |
r"t j d
j yt j d
y |
r3t j d
j ||j
S t j d ||j t )zTry to find a Link matching req
Expects req, an InstallRequirement and upgrade, a boolean
Returns a InstallationCandidate if found,
Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
Nz&find_requirement() called with no nameF)trust_internet)r r c
dj t | D ch c] }t |j c}t xs dS c c}w )Nrc rv none)r0 r r2 r:
parse_version) cand_iterr s r; _format_versionsz8PackageFinder.find_requirement.._format_versions sI 1:;AQYY ; )
._should_install_candidate s) !( % !)),== =rM zUExisting installed version (%s) satisfies requirement (most up-to-date version is %s)zLExisting installed version (%s) is most up-to-date and satisfies requirementz)Using version %s (newest of versions: %s)z=Installed version (%s) is most up-to-date (past versions: %s))rf z Iterable[InstallationCandidate]rx r2 )rD r rx z TypeGuard[InstallationCandidate])r r r` r r satisfied_byr: r r r r3 criticalr r r5 r r ) rX requpgrader r best_candidate_resultrg version_type
allows_prerj r ri s @@r; find_requirementz PackageFinder.find_requirement s xx I!II 51 $ 8 8 mm !9 !
/==15 ' # 0 0 8 8
$ )?$L##/ ! 1 1 D D%d+
L OO& !6!E!EF
')LSE'RS S >3 >
- > ,8( 8 6%"** ,%
$^ 4 LL; && !6!L!LM
" ! K 2 H H I
*)rM )NNFN)r r r[ r r\ r r zFormatControl | Noner zCandidatePreferences | Noner8 r r] r rx r )NN)
r r r r r[ r r] r rx r* )rx r )rx r )r r rx r )rx z list[str])rx
str | None)rx z
Iterable[str])rx r )r r rx r )rx r r )rx r )rW r2 rx rO )r+ Iterable[Link]rx z
list[Link])r7 r r1 r> r2 r2 rx r )r5 rO r7 r rx r )r5 rO r+ rt rx r )r; r r5 rO rx r )rW r2 rx r )rW r2 r r r r rx r )rW r2 r r r r rx r) )rm r rn r rx r )!r? r@ rA r r^ r r propertyr[ r setterr r r r r r r r r r" r] r% r( r/ r3 r6 r8 r? r[ r] r` rr r+ rM r; r* r* f s 047;',6:,%, $, ,
- , 5
, !%, 4,
,d
.26: !
%!
.!
+ !
4 !
!
!
F # # 1 1 9 9 / / , , 6 6 + + ; ;
5 5@ 3 33 ' '5
6 +37 %2 + 4B $ 1> $ *72x 6: $
3
( 6: $ FF 3F F
F:b*%b*04b* %b*rM r* c ~ t | D ] \ }}|dk7 r t | d| |k( s |c S t | d| )a Find the separator's index based on the package's canonical name.
:param fragment: A + filename "fragment" (stem) or
egg fragment.
:param canonical_name: The package's canonical name.
This function is needed since the canonicalized name does not necessarily
have the same length as the egg info's name part. An example::
>>> fragment = 'foo__bar-1.0'
>>> canonical_name = 'foo-bar'
>>> _find_name_version_sep(fragment, canonical_name)
8
-Nz does not match )r r r )fragmentrY ir s r; _find_name_version_sepr{ 0 sS $ (#1 8 Xbq\ *n <H $
z!1.1AB
CCrM c T t | | dz }| |d }|sy|S # t $ r Y yw xY w)zParse the version string from a + filename
"fragment" (stem) or egg fragment.
:param fragment: The string to parse. E.g. foo-2.1
:param canonical_name: The canonicalized name of the package this
belongs to.
rf N)r{ r )ry rY
version_startr: s r; r r J sE .x H1L
}~&G N s '')F)r7 r r- ztuple[int, int, int]r8 r rx r )r r r r rW r2 rx r )ry r2 rY r2 rx rk )ry r2 rY r2 rx rs )]r
__future__r datetimerB rK rM rQ r collections.abcr dataclassesr typingr r r pip._vendor.packagingr pip._vendor.packaging.tagsr
pip._vendor.packaging.utilsr r pip._vendor.packaging.versionr
r r re pip._internal.exceptionsr r r r r pip._internal.index.collectorr r pip._internal.metadatar pip._internal.models.candidater #pip._internal.models.format_controlr pip._internal.models.linkr $pip._internal.models.release_controlr !pip._internal.models.search_scoper $pip._internal.models.selection_prefsr "pip._internal.models.target_pythonr pip._internal.models.wheelr pip._internal.reqr pip._internal.utils._logr! pip._internal.utils.filetypesr" pip._internal.utils.hashesr# pip._internal.utils.loggingr$ pip._internal.utils.miscr% pip._internal.utils.packagingr& pip._internal.utils.unpackingr' typing_extensionsr( __all__r? r3 rp rk r2 BuildTagr r< Enumr> rO r r r) r r* r{ r r+ rM r; r s ' " $ ! - * I F @ E 1 @ = * ? 9 E ; , 0 . 9 - 2 1 ? >+
C
8 rE#s(O+ ,Cc<# PQ $),
,&, !,
,^ &tyy &o- o-dG+G G G ! GT 2 2 2 $E E E2H
H
VG* G*TD4rM PK ! ?R" $ __pycache__/__init__.cpython-312.pycnu [
-r*j d Z y)zIndex interaction codeN)__doc__ K/opt/hc_python/lib/python3.12/site-packages/pip/_internal/index/__init__.pyr s r PK ! Ȏug/ / # __pycache__/sources.cpython-312.pycnu [
-r*j! d dl mZ d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m Z m
Z
mZmZmZ d dlmZ d dlmZ d d lmZmZ d d
lmZ ej4 e Z ee Z ee Z e
egee f Z e
ege f Z! G d d Z"dd
Z# G d d Z$ G d de" Z% G d de" Z& G d de" Z' G d de" Z( ddZ)y) ) annotationsN) defaultdict)Iterable)Callable)InvalidSdistFilenameInvalidWheelFilenamecanonicalize_nameparse_sdist_filenameparse_wheel_filename)InstallationCandidate)Link) path_to_url url_to_path)is_urlc . e Zd Zedd ZddZddZy)
LinkSourcec t )z,Returns the underlying link, if there's one.NotImplementedErrorselfs J/opt/hc_python/lib/python3.12/site-packages/pip/_internal/index/sources.pylinkzLinkSource.link s
"## c t )z9Candidates found by parsing an archive listing HTML file.r r s r page_candidateszLinkSource.page_candidates% !##r c t )z,Links found by specifying archives directly.r r s r
file_linkszLinkSource.file_links) r r Nreturnz Link | Noner! FoundCandidatesr!
FoundLinks)__name__
__module__ __qualname__propertyr r r r r r r s
$ $$$r r c < t j | d d dk( S )NF)strictr z text/html) mimetypes
guess_type)file_urls r
_is_html_filer0 . s 7 :k IIr c D e Zd ZdZddZddZed d Zed
d Zy) _FlatDirectoryToUrlsz"Scans directory and caches resultsc V || _ g | _ t t | _ d| _ y )NF)_path_page_candidatesr list_project_name_to_urls_scanned_directory)r paths r __init__z _FlatDirectoryToUrls.__init__5 s&
+- ;Ft;L""' r c t j | j D ]u }t |j }t | r | j j | ? t |j d }| j | j | w d| _ y# t $ r- t |j d }n# t $ r Y Y w xY wY ]w xY w)zrScans directory once and populates both page_candidates
and project_name_to_urls at the same time
r TN)osscandirr4 r r9 r0 r5 appendr namer r
r r7 r8 )r entryurlproject_filenames r _scan_directoryz$_FlatDirectoryToUrls._scan_directory; s ZZ
+E ejj)C S!%%,,S1
#7
#CA#F
& &'7 8 ? ? D! ," #' (
';EJJ'G'J$+ %
s6 B C*CC C CCCCc R | j s| j | j S N)r8 rC r5 r s r r z$_FlatDirectoryToUrls.page_candidatesR s# && "$$$r c R | j s| j | j S rE )r8 rC r7 r s r project_name_to_urlsz)_FlatDirectoryToUrls.project_name_to_urlsY s# && ")))r N)r9 strr! None)r! rI )r! z list[str])r! zdict[str, list[str]]) r& r' r( __doc__r: rC r) r rG r* r r r2 r2 2 s7 ,( '. % % * *r r2 c Z e Zd ZU dZi Zded< d dZed
d Zd dZ d dZ
y)
_FlatDirectorySourcezLink source specified by ``--find-links=``.
This looks the content of the directory, and returns:
* ``page_candidates``: Links listed on each HTML file in the directory.
* ``file_candidates``: Archives in the directory.
z dict[str, _FlatDirectoryToUrls]_paths_to_urlsc || _ t | | _ || j v r| j | | _ y t | | _ | j | j |< y )N)r9 )_candidates_from_pager
_project_namerM
_path_to_urlsr2 )r candidates_from_pager9 project_names r r: z _FlatDirectorySource.__init__l s_ &:" .| < 4&& &!%!4!4T!:D !54!@D (,(:(:D %r c y rE r* r s r r z_FlatDirectorySource.link| s r c # K | j j D ]$ }| j t | E d { & y 7 wrE )rQ r rO r
r rA s r r z$_FlatDirectorySource.page_candidates s7 %%55C11$s)< < < 6 `` or ``--[extra-]index-url=``.
If a URL is supplied, it must be a ``file:`` URL. If a path is supplied to
the option, it is converted to a URL first. This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
c || _ || _ y rE rO _linkr rR r s r r: z_LocalFileSource.__init__
&:"
r c | j S rE r^ r s r r z_LocalFileSource.link zzr c # K t | j j sy | j | j E d { y 7 wrE )r0 r^ rA rO r s r r z _LocalFileSource.page_candidates s1 TZZ^^, --djj999s ?A AA c # h K t | j j ry | j y wrE )r0 r^ rA r s r r z_LocalFileSource.file_links s# ( jjs 02NrR rX r r
r! rI r r" r$ r& r' r( rJ r: r) r r r r* r r r[ r[ sF 0
:
r r[ c J e Zd ZdZ ddZedd Zd dZd
dZy) _RemoteFileSourcez``--find-links=`` or ``--[extra-]index-url=``.
This returns:
* ``page_candidates``: Links listed on an HTML file.
* ``file_candidates``: The non-HTML file.
c . || _ || _ || _ y rE )rO _page_validatorr^ )r rR page_validatorr s r r: z_RemoteFileSource.__init__ s &:" -
r c | j S rE rb r s r r z_RemoteFileSource.link rc r c # K | j | j sy | j | j E d { y 7 wrE )rk r^ rO r s r r z!_RemoteFileSource.page_candidates s3 ##DJJ/ --djj999s ;AAAc # ( K | j y wrE rb r s r r z _RemoteFileSource.file_links s jjs N)rR rX rl
PageValidatorr r
r! rI r r" r$ rg r* r r ri ri sP 0 &
:
r ri c F e Zd ZdZ ddZedd Zd dZd
dZy) _IndexDirectorySourcez``--[extra-]index-url=``.
This is treated like a remote URL; ``candidates_from_page`` contains logic
for this by appending ``index.html`` to the link.
c || _ || _ y rE r] r_ s r r: z _IndexDirectorySource.__init__ r` r c | j S rE rb r s r r z_IndexDirectorySource.link rc r c # V K | j | j E d { y 7 wrE r] r s r r z%_IndexDirectorySource.page_candidates s --djj999s )')c y)Nr* r* r s r r z _IndexDirectorySource.file_links s r Nrf r r" r$ rg r* r r rr rr sF 0
:r rr c x d }d }t j j | rt | }| }n,| j d r| }t | }n
t
| r| }|d}t j || y| t ||t || } || fS t j j | r0|rt ||| } || fS t |t || } || fS t j j | r t |t || } || fS t j d| |d fS ) Nzfile:zVLocation '%s' is ignored: it is either a non-existing path or lacks a specific scheme.)NN)cache_link_parsing)rR rl r )rR r9 rS )rR r z?Location '%s' is ignored: it is neither a file nor a directory.)r< r9 existsr
startswithr r loggerwarningri r
isdirrL rr isfiler[ )
locationrR rl
expand_dirrx rS r9 rA msgsources
r build_sourcer sP DC ww~~h (# W %8$
{
K sH% | .!5)c.@A
V} ww}}T )%9 )F V} +%9#2DEF V} !!5c.@A
V}
NNI
;r )r/ rH r! bool)r rH rR rX rl rp r r rx r rS rH r! z$tuple[str | None, LinkSource | None])*
__future__r loggingr- r< collectionsr collections.abcr typingr pip._vendor.packaging.utilsr r r r
r pip._internal.models.candidater pip._internal.models.linkr
pip._internal.utils.urlsr r pip._internal.vcsr getLoggerr& r{ r# r% rX r rp r r0 r2 rL r[ ri rr r r* r r r s " # $ A * = $ 8 $01
d^
tfh/D&E EF $ &
$ $ J,* ,*^% : % P z B
@J 4;; -; " ;
;
; ; *;r PK ! LR LR % __pycache__/collector.cpython-312.pycnu [
-r*j? d Z ddlmZ ddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl
mZmZmZ ddlmZ ddlmZ ddlmZ ddlmZmZmZ dd lm Z dd
l m Z dd l m Z m!Z! dd l"m#Z# dd
l$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6m7Z7 e jp e9 Z:ee;e;f Z Z?d4dZ@ G d d e> ZAd5d ZBd6d ZCd7d ZD G d d! ZE G d" d#e ZFd8d$ZGeGd9d& ZH ed'( G d) d% ZI G d* d+e ZJ d: d;d,ZK d< d=d-ZLd>d.ZM G d/ d0e ZN G d1 d2 ZOy)?zO
The main purpose of this module is to expose LinkCollector.collect_sources().
) annotationsN)IterableMutableMappingSequence) dataclass)
HTMLParser)Values)Callable
NamedTupleProtocol)requests)Response)
RetryErrorSSLError)NetworkConnectionError)Link) SearchScope)
PipSession)raise_for_status)is_archive_fileredact_auth_from_url) url_to_path)vcs )CandidatesFromPage
LinkSource build_sourcec t j D ]6 }| j j | s#| t | dv s4|c S y)zgLook for VCS schemes in the URL.
Returns the matched VCS scheme, or None if there's no match.
z+:N)r schemeslower
startswithlen)urlschemes L/opt/hc_python/lib/python3.12/site-packages/pip/_internal/index/collector.py_match_vcs_schemer' . s@
++ 99; ! !& )c#f+.>$.FM c e Zd Zd fd Z xZS )_NotAPIContentc B t | || || _ || _ y N)super__init__ content_type request_desc)selfr/ r0 __class__s r& r. z_NotAPIContent.__init__: s"
|4 ( (r( )r/ strr0 r3 returnNone)__name__
__module__ __qualname__r.
__classcell__r2 s @r& r* r* 9 s
) )r( r* c | j j dd }|j }|j d ryt || j
j )z
Check the Content-Type header to ensure the response contains a Simple
API Response.
Raises `_NotAPIContent` if the content type is not a valid content-type.
Content-TypeUnknown)z text/htmlz#application/vnd.pypi.simple.v1+html#application/vnd.pypi.simple.v1+jsonN)headersgetr! r" r* requestmethod)responser/ content_type_ls r& _ensure_api_headerrE @ s[ ##'' BL!'')N
x'7'7'>'>
??r( c e Zd Zy)_NotHTTPN)r6 r7 r8 r( r& rG rG V s r( rG c t j j | \ }}}}}|dvr
t |j | d }t | t
| y)z
Send a HEAD request to the URL, and ensure the response contains a simple
API Response.
Raises `_NotHTTP` if the URL is not available for a HEAD request, or
`_NotAPIContent` if the content type is not a valid content type.
> httphttpsT)allow_redirectsN)urllibparseurlsplitrG headr rE )r$ sessionr% netlocpathqueryfragmentresps r& _ensure_api_responserW Z sV -3LL,A,A#,F)FFD%
&&j <<T< 2DTt r( c t t | j r
t | | t j dt
| |j | dj g d dd }t | t | t j dt
| |j j d d
|S ) aY Access an Simple API response with GET, and return the response.
This consists of three parts:
1. If the URL looks suspiciously like an archive, send a HEAD first to
check the Content-Type is HTML or Simple API, to avoid downloading a
large file. Raise `_NotHTTP` if the content type cannot be determined, or
`_NotAPIContent` if it is not HTML or a Simple API.
2. Actually perform the request. Raise HTTP exceptions on network failures.
3. Check the Content-Type header to make sure we got a Simple API response,
and raise `_NotAPIContent` otherwise.
rQ zGetting page %sz, )r> z*application/vnd.pypi.simple.v1+html; q=0.1ztext/html; q=0.01z max-age=0)Acceptz
Cache-Control)r? zFetched page %s as %sr< r= ) r r filenamerW loggerdebugr r@ joinr rE r? )r$ rQ rV s r& _get_simple_responser_ l s tCy))* S'2
LL"$8$=> ;; ii( )+
D4 T t
LL S! 3 Kr( c | rHd| v rDt j j }| d |d< |j d }|r t | S y)z=Determine if we have any encoding information in our headers.r< z content-typecharsetN)emailmessageMessage get_paramr3 )r? mra s r& _get_encoding_from_headersrg sK >W, MM ! ! # #N 3.++i( w< r( c $ e Zd ZddZddZddZy)CacheablePageContentc . |j sJ || _ y r, )cache_link_parsingpager1 rl s r& r. z CacheablePageContent.__init__ s &&&& r( c t |t | xr- | j j |j j k( S r, )
isinstancetyperl r$ )r1 others r& __eq__zCacheablePageContent.__eq__ s- %d,P %**..1PPr( c @ t | j j S r, )hashrl r$ r1 s r& __hash__z CacheablePageContent.__hash__ s DIIMM""r( N)rl IndexContentr4 r5 )rq objectr4 bool)r4 int)r6 r7 r8 r. rr rv rH r( r& ri ri s Q#r( ri c e Zd ZddZy)
ParseLinksc y r, rH rm s r& __call__zParseLinks.__call__ s cr( Nrl rw r4 zIterable[Link])r6 r7 r8 r~ rH r( r& r| r| s Ar( r| c z t j d fd t j d fd }|S )z
Given a function that parses an Iterable[Link] from an IndexContent, cache the
function's result (keyed by CacheablePageContent), unless the IndexContent
`page` has `page.cache_link_parsing == False`.
c : t | j S r, )listrl )cacheable_pagefns r& wrapperz*with_cached_index_content..wrapper s B~**+,,r( c ` | j r t | S t | S r, )rk ri r )rl r r s r& wrapper_wrapperz2with_cached_index_content..wrapper_wrapper s+ " "/56 6BtH~ r( )r ri r4
list[Link])rl rw r4 r ) functoolscachewraps)r r r s ` @r& with_cached_index_contentr s@ __- - __R
r( rw c # T K | j j }|j d r^t j | j
}|j
dg D ]) }t j || j }|&| + yt | j }| j xs d}|j | j
j | | j }|j xs |}|j D ]! } t j | || }| | # yw)z\
Parse a Simple API's Index Content, and yield its anchor elements as Link objects.
r> filesNzutf-8)page_urlbase_url)r/ r! r" jsonloadscontentr@ r from_jsonr$ HTMLLinkParserencodingfeeddecoder anchors from_element)
rl rD datafilelinkparserr r$ r anchors
r& parse_linksr s &&,,.N !FGzz$,,'HHWb)D>>$1D|J *
DHH
%F}}'H
KK ##H-.
((C%#H.. #I <
!s D&D(T)frozenc P e Zd ZU dZded< ded< ded< ded< d Zd
ed < dd Zy
)rw a Represents one response (or page), along with its URL.
:param encoding: the encoding to decode the given content.
:param url: the URL from which the HTML was downloaded.
:param cache_link_parsing: whether links parsed from this page's url
should be cached. PyPI index urls should
have this set to False, for example.
bytesr r3 r/
str | Noner r$ Try rk c , t | j S r, )r r$ ru s r& __str__zIndexContent.__str__ s #DHH--r( N)r4 r3 )r6 r7 r8 __doc____annotations__rk r rH r( r& rw rw s/ N H ##.r( c 4 e Zd ZdZd fd ZddZddZ xZS )r zf
HTMLParser that keeps the first base HREF and a list of all anchor
elements' attributes.
c P t | d || _ d | _ g | _ y )NT)convert_charrefs)r- r. r$ r r )r1 r$ r2 s r& r. zHTMLLinkParser.__init__ s(
$/$(
46 r( c |dk( r(| j | j | }||| _ y y |dk( r%| j j t | y y )Nbasea)r get_hrefr appenddict)r1 tagattrshrefs r& handle_starttagz HTMLLinkParser.handle_starttag sT &=T]] 2=='D $
CZ LL U , r( c * |D ] \ }}|dk( s |c S y )Nr rH )r1 r namevalues r& r zHTMLLinkParser.get_href! s! KD%v~ ! r( )r$ r3 r4 r5 )r r3 r list[tuple[str, str | None]]r4 r5 )r r r4 r )r6 r7 r8 r r. r r r9 r: s @r& r r s
7-r( r c < |t j } |d| | y )Nz%Could not fetch URL %s: %s - skipping)r\ r] )r reasonmeths r& _handle_get_simple_failr ( s
||| 0$?r( c t | j }t | j | j d || j | S )Nr< )r r$ rk )rg r? rw r r$ )rC rk r s r& _make_index_contentr 2 sE *(*:*:;H ( LL- r( c $ | j j dd d }t | }|rt j d|| y |j d rtt j j t | rL|j d s|dz
}t j j |d }t j d| t || }t! || j"
S # t$ $ r t j d | Y y t& $ r6}t j d | |j( |j* Y d }~y d }~wt, $ r}t/ | | Y d }~y d }~wt0 $ r}t/ | | Y d }~y d }~wt2 $ r6}d
}|t5 | z
}t/ | |t j6 Y d }~y d }~wt8 j: $ r}t/ | d| Y d }~y d }~wt8 j< $ r t/ | d Y y w xY w)N#r r zICannot look at %s URL %s because it does not support lookup as web pages.zfile:/z
index.htmlz# file: URL is directory, getting %srY )rk z`Skipping page %s because it looks like an archive, and cannot be checked by a HTTP HEAD request.zSkipping page %s because the %s request got Content-Type: %s. The only supported Content-Types are application/vnd.pypi.simple.v1+json, application/vnd.pypi.simple.v1+html, and text/htmlz4There was a problem confirming the ssl certificate: )r zconnection error: z timed out) r$ splitr' r\ warningr" osrS isdirr endswithrM rN urljoinr] r_ r rk rG r* r0 r/ r r r r r3 infor
ConnectionErrorTimeout)r rQ r$
vcs_schemerV excr s r& _get_index_contentr ? s
((..a
#C #3'J W
~~g 277==S1A#B ||C 3JC
ll""3 5 :C@ U#C9: #4Dz'LinkCollector.create.. s Ijs-c2js )r r no_index)rQ r )
index_urlextra_index_urlsr r\ r] r^ r r creater )clsrQ optionssuppress_no_indexr r r link_collectors r& r zLinkCollector.create s ''(7+C+CC
$5 LL&IjII
J ''-2
"))!! %%
'%
r( c . | j j S r, )r r ru s r& r zLinkCollector.find_links s +++r( c 0 t || j S )z>
Fetch an HTML page containing package links.
rY )r rQ )r1 locations r& fetch_responsez LinkCollector.fetch_response s "(DLLAAr( c t j fd j j D j }t j fd j
D j }t j t j rwt j || D cg c] }||j d|j ! }}t | d dg|z }t j dj | t! t# | t# | S c c}w )Nc 3 h K | ]) }t |j j d d + yw)Fcandidates_from_pagepage_validator
expand_dirrk project_nameNr rQ is_secure_originr locr r r1 s r& r z0LinkCollector.collect_sources.. sE
4
P
%9 #|| < < #( )
P /2c 3 h K | ]) }t |j j d d + yw)Tr Nr r s r& r z0LinkCollector.collect_sources.. sC
5
'
%9 #|| < < #' )
'r z* z' location(s) to search for versions of :
)r r ) collections OrderedDictr get_index_urls_locationsvaluesr r\ isEnabledForloggingDEBUG itertoolschainr r# r] r^ r r )r1 r r index_url_sourcesfind_links_sourcessliness ``` r& collect_sourcesz LinkCollector.collect_sources s5 ( 3 3
4
((AA,O
4
&( ) 4 4
5
5
&( w}} - # );=NOOA=QVV%7 QVVH
O
u:, ##/.3 E
LL5) * ./ -.
s >$D<N)rQ r r r r4 r5 )F)rQ r r r r ry r4 r )r4 z list[str])r r r4 IndexContent | None)r r3 r r r4 r ) r6 r7 r8 r r. classmethodr propertyr r r rH r( r& r r s "
#(
B , ,B ,
,
1,
,
r( r )r$ r3 r4 r )rC r r4 r5 )r$ r3 rQ r r4 r5 )r$ r3 rQ r r4 r )r? ResponseHeadersr4 r )r r| r4 r| r r, )r r r zstr | Exceptionr zCallable[..., None] | Noner4 r5 )T)rC r rk ry r4 rw )r r rQ r r4 r )Pr
__future__r r
email.messagerb r r r r r urllib.parserM collections.abcr r r dataclassesr html.parserr optparser typingr
r r pip._vendorr
pip._vendor.requestsr pip._vendor.requests.exceptionsr r pip._internal.exceptionsr pip._internal.models.linkr !pip._internal.models.search_scoper pip._internal.network.sessionr pip._internal.network.utilsr pip._internal.utils.filetypesr pip._internal.utils.miscr pip._internal.utils.urlsr pip._internal.vcsr sourcesr r r getLoggerr6 r\ r3 r r' Exceptionr* rE rG rW r_ rg ri r| r r rw r r r r r r rH r( r& r s # > > ! " ! ) @ ; * 9 4 8 9 9 0 ! A A 8 $ c*)Y )@, y $<~ # #B B( 8 $. . .(Z > (,@
@ @ %@
@ 48
,0
9x,z ,
h
h
r( PK ! 1%m m ) __pycache__/package_finder.cpython-39.pycnu [ PK ! >k> > " ?n __pycache__/sources.cpython-39.pycnu [ PK ! Srl # ϊ __pycache__/__init__.cpython-39.pycnu [ PK ! /> /> $ + __pycache__/collector.cpython-39.pycnu [ PK ! +
sources.pynu [ PK ! I~D ~D collector.pynu [ PK ! C?K ?) __init__.pynu [ PK ! W ) package_finder.pynu [ PK ! 9
$ ѷ __pycache__/__init__.cpython-311.pycnu [ PK ! { `n4 4 * 2 __pycache__/package_finder.cpython-311.pycnu [ PK ! FX5 X5 # r __pycache__/sources.cpython-311.pycnu [ PK ! #] ] % k __pycache__/collector.cpython-311.pycnu [ PK ! L) ) * __pycache__/package_finder.cpython-312.pycnu [ PK ! ?R" $ J __pycache__/__init__.cpython-312.pycnu [ PK ! Ȏug/ / # o __pycache__/sources.cpython-312.pycnu [ PK ! LR LR % __pycache__/collector.cpython-312.pycnu [ PK b5