File: //lib/python3.9/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-39.pyc
a
?�f�I � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
m Z m Z m
Z
mZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZmZ dd
lm Z ddl m Z m Z ddl m!Z! e!�rZddl"m#Z#m$Z$m%Z%m&Z&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3 ddlm4Z4 ddlm5Z5 e#e6e$e4 f Z7e�8e9�Z:d dd�Z;G d d � d e�Z<dS ) ay Dependency Resolution
The dependency resolution in pip is performed as follows:
for top-level requirements:
a. only one spec allowed per project, regardless of conflicts or not.
otherwise a "double requirement" exception is raised
b. they override sub-dependency requirements.
for sub-dependencies
a. "first found, wins" (where the order is breadth first)
� N)� defaultdict)�chain)�
specifiers)�BestVersionAlreadyInstalled�DistributionNotFound� HashError�
HashErrors�UnsupportedPythonVersion)� check_invalid_constraint_type)�RequirementSet)� BaseResolver)�
get_supported)�
indent_log)�dist_in_usersite�normalize_version_info)�dist_in_install_path)�check_requires_python�get_requires_python)�MYPY_CHECK_RUNNING)� DefaultDict�List�Optional�Set�Tuple)�
pkg_resources)�
WheelCache)�AbstractDistribution)�
PackageFinder)�Link)�RequirementPreparer)�InstallRequirement)�InstallRequirementProviderFc
C s� t | �}zt||d�}W n8 tjyP } z t�d| j|� W Y d}~dS d}~0 0 |rZdS d�tt |��}|r�t�
d| j||� dS t d� | j||���dS )a�
Check whether the given Python version is compatible with a distribution'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.
:raises UnsupportedPythonVersion: When the given Python version isn't
compatible.
)� version_infoz-Package %r has an invalid Requires-Python: %sN�.zBIgnoring failed Requires-Python check for package %r: %s not in %rz8Package {!r} requires a different Python: {} not in {!r})
r r r ZInvalidSpecifier�logger�warningZ project_name�join�map�str�debugr �format)�distr" �ignore_requires_pythonZrequires_pythonZ
is_compatible�exc�version� r/ �L/usr/lib/python3.9/site-packages/pip/_internal/resolution/legacy/resolver.py�_check_dist_requires_python= s2 �
����r1 c sr e Zd ZdZh d�Zd� fdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Z� ZS )�Resolverz�Resolves which packages need to be installed/uninstalled to perform the requested operation without breaking the requirements of any package.
> �to-satisfy-only�eager�only-if-neededNc s� t t| ��� |
| jv s J �| d u r4tjd d� } nt| �} | | _|| _|| _ || _
|
| _ | | _ || _
|| _|| _|| _|| _tt�| _d S )N� )�superr2 �__init__�_allowed_strategies�sysr" r �_py_version_info�preparer�finder� wheel_cache�upgrade_strategy�force_reinstall�ignore_dependencies�ignore_installedr, �
use_user_site�_make_install_reqr �list�_discovered_dependencies) �selfr< r= r> Zmake_install_reqrC rA rB r, r@ r? Zpy_version_info�� __class__r/ r0 r8 t s$ �zResolver.__init__c C s� t |d�}|D ] }|jr t|� |�|� qg }t� }t|j|�D ]P}z|�| �||�� W qB t y� } z ||_
|� |� W Y d}~qBd}~0 0 qB|r�|�|S )a� Resolve what operations need to be done
As a side-effect of this method, the packages (and their dependencies)
are downloaded, unpacked and prepared for installation. This
preparation is done by ``pip.operations.prepare``.
Once PyPI has static dependency metadata available, it would be
possible to move the preparation to become a step separated from
dependency resolution.
)�check_supported_wheelsN) r �
constraintr
�add_requirementr r Zall_requirements�extend� _resolve_oner �req�append)rG Z root_reqsrJ �requirement_setrO Zdiscovered_reqsZ hash_errorsr- r/ r/ r0 �resolve� s$ � "zResolver.resolvec C s: | j dkrdS | j dkr dS | j dks*J �|jp4|jS d S )Nr3 Fr4 Tr5 )r? �
user_suppliedrK �rG rO r/ r/ r0 �_is_upgrade_allowed� s
z Resolver._is_upgrade_allowedc C s* | j rt|j�r t|j�r d|_d|_dS )z4
Set a requirement to be installed.
TN)rC r � satisfied_byr Zshould_reinstallrT r/ r/ r0 �_set_req_to_reinstall� s ��z Resolver._set_req_to_reinstallc C s� | j r
dS |�| j� |js dS | jr4| �|� dS | �|�sP| jdkrLdS dS |js�z| j j
|dd� W n$ t y~ Y dS t y� Y n0 | �|� dS )a Check if req_to_install should be skipped.
This will check if the req is installed, and whether we should upgrade
or reinstall it, taking into account all the relevant user options.
After calling this req_to_install will only have satisfied_by set to
None if the req_to_install is to be upgraded/reinstalled etc. Any
other value will be a dist recording the current thing installed that
satisfies the requirement.
Note that for vcs urls and the like we can't assess skipping in this
routine - we simply identify that we need to pull the thing down,
then later on it is pulled down and introspected to assess upgrade/
reinstalls etc.
:return: A text reason for why it was skipped, or None.
Nr5 z#already satisfied, skipping upgradezalready satisfiedT)�upgradezalready up-to-date)
rB �check_if_existsrC rV r@ rW rU r? �linkr= �find_requirementr r )rG �req_to_installr/ r/ r0 �_check_skip_installed� s*
z Resolver._check_skip_installedc C sR | � |�}| j�||�}|s d S |j}|jrN|jp4d}dj||d�}t�|� |S )Nz <none given>zqThe candidate selected for download or install is a yanked version: {candidate}
Reason for being yanked: {reason})� candidate�reason) rU r= r[ rZ Z is_yankedZ
yanked_reasonr* r$ r% )rG rO rX Zbest_candidaterZ r_ �msgr/ r/ r0 �_find_requirement_link s
��
z Resolver._find_requirement_linkc C s~ |j du r| �|�|_ | jdu s(| jjr,dS | jj|j |jt� d�}|durzt� d|j � |j |j
u rr|j rrd|_ |j |_ dS )af Ensure that if a link can be found for this, that it is found.
Note that req.link may still be None - if the requirement is already
installed and not needed to be upgraded based on the return value of
_is_upgrade_allowed().
If preparer.require_hashes is True, don't use the wheel cache, because
cached wheels, always built locally, have different hashes than the
files downloaded from the index server and thus throw false hash
mismatches. Furthermore, cached wheels at present have undeterministic
contents due to file modification times.
N)rZ Z package_nameZsupported_tagszUsing cached wheel link: %sT)
rZ ra r> r< Zrequire_hashesZget_cache_entry�namer
r$ r) Z
original_linkZ
persistentZ original_link_is_in_wheel_cache)rG rO Z cache_entryr/ r/ r0 �_populate_link% s
�zResolver._populate_linkc C s� |j r| j�|�S |jdu s J �| �|�}|jr>| j�||�S | �|� | j�|�}| jsf|� | j
� |jr�| j dkp�| j p�| jp�|j
jdk}|r�| �|� n t�d|� |S )zzTakes a InstallRequirement and returns a single AbstractDist representing a prepared variant of the same.
Nr3 �filez<Requirement already satisfied (use --upgrade to upgrade): %s)�editabler< Z prepare_editable_requirementrV r] Z prepare_installed_requirementrc Zprepare_linked_requirementrB rY rC r? r@ rZ �schemerW r$ �info)rG rO Z skip_reason�
abstract_distZ
should_modifyr/ r/ r0 �_get_abstract_dist_forC s6
�
��
� �z Resolver._get_abstract_dist_forc
s< �j s �jrg S d�_����}|�� }t|�j�jd� g � � ���fdd�}t� �� ���j �s|�j
snJ ��j �dd� �j �s�j
r�t�dd��j
�� tt�j
�t|j
� �}|D ]}t�d ||� q�tt|j
�t�j
�@ �}|�|�D ]} || |d
� q�j�s�j�sd�_W d � n1 �s.0 Y � S ) zxPrepare a single requirements file.
:return: A list of additional InstallRequirements to also install.
T)r" r, c sP �� t| ���}�j}�j|||d�\}}|rB|rB�j| �|� � �|� d S )N)�parent_req_name�extras_requested)rD r( rb rL rF rP rM )�subreqrk Zsub_install_reqrj Z
to_scan_againZ
add_to_parent�Z more_reqsr\ rQ rG r/ r0 �add_req� s ��
�z&Resolver._resolve_one.<locals>.add_reqN)rj z!Installing extra requirements: %r�,z"%s does not provide the extra '%s')rk )rK Zpreparedri Z get_pkg_resources_distributionr1 r; r, r Zhas_requirementrb rS rL rA Zextrasr$ r) r& �sorted�setr% Zrequiresre rV Zsuccessfully_downloaded)
rG rQ r\ rh r+ rn Zmissing_requestedZmissingZavailable_requestedrl r/ rm r0 rN u sN
�
�
����&zResolver._resolve_onec s8 g � t � �� ���fdd��|j�� D ] }�|� q&� S )z�Create the installation order.
The installation order is topological - requirements are installed
before the requiring thing. We break cycles at an arbitrary point,
and make no other guarantees.
c sN | j s| �v rd S | jr d S ��| � �j| j D ] }�|� q2� �| � d S )N)rV rK �addrF rb rP )rO Zdep��orderZ ordered_reqs�schedulerG r/ r0 ru � s
z1Resolver.get_installation_order.<locals>.schedule)rq Z requirements�values)rG Zreq_setZ install_reqr/ rs r0 �get_installation_order� s
z Resolver.get_installation_order)N)�__name__�
__module__� __qualname__�__doc__r9 r8 rR rU rW r] ra rc ri rN rw �
__classcell__r/ r/ rH r0 r2 m s �(&
5 2Yr2 )F)=r{ Zloggingr: � collectionsr � itertoolsr Zpip._vendor.packagingr Zpip._internal.exceptionsr r r r r Z pip._internal.req.req_installr
Zpip._internal.req.req_setr Z pip._internal.resolution.baser Z&pip._internal.utils.compatibility_tagsr
Zpip._internal.utils.loggingr Zpip._internal.utils.miscr r r Z pip._internal.utils.packagingr r Zpip._internal.utils.typingr �typingr r r r r Z pip._vendorr Zpip._internal.cacher Zpip._internal.distributionsr Z"pip._internal.index.package_finderr Zpip._internal.models.linkr Z pip._internal.operations.preparer r r! r( ZDiscoveredDependenciesZ getLoggerrx r$ r1 r2 r/ r/ r/ r0 �<module> s<
�
0