File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/pip/_vendor/resolvelib/resolvers/__pycache__/resolution.cpython-310.pyc
Back
o ;j�] � @ s& U d dl mZ d dlZd dlZd dlZd dlmZmZ ddlm Z m Z m Z m Z m Z mZmZmZmZ ddlmZmZ ddlmZ dd lmZmZmZmZm Z ergd d l m Z m Z m Z dd l!m"Z"m#Z# dd l$m%Z% d Z&de'd< d%dd�Z(G dd� dee e e f �Z)G dd� dee e e f �Z*d&d#d$�Z+dS )'� )� annotationsN)� TYPE_CHECKING�Generic� ) �CT�KT�RT� DirectedGraph� IterableView�IteratorMapping�RequirementInformation�State�build_iter_view� )�AbstractResolver�Result)� Criterion)�InconsistentCandidate�RequirementsConflicted�ResolutionImpossible�ResolutionTooDeep�ResolverException)� Collection�Iterable�Mapping)�AbstractProvider� Preference)� BaseReporterg�������?�float� _OPTIMISTIC_BACKJUMPING_RATIO�state�State[RT, CT, KT]�return�Result[RT, CT, KT]c s� | j }dd� |�� D �}d |td �< t� }|�d � d h� | j�� D ]>\}}t| j||� �s/q"||vr8|�|� |�� D ]#}z|t|� }W n tyO Y q<w ||vrY|�|� |� ||� q<q"t � fdd�|�� D �|| jd�S )Nc S s i | ] \}}t |�|�qS � )�id��.0�k�vr$ r$ �_/opt/saltstack/salt/lib/python3.10/site-packages/pip/_vendor/resolvelib/resolvers/resolution.py� <dictcomp>( s z!_build_result.<locals>.<dictcomp>c s i | ] \}}|� v r||�qS r$ r$ r& �� connectedr$ r* r+ > s )�mapping�graph�criteria) r. �itemsr% r �addr0 �_has_route_to_root� iter_parent�KeyError�connectr )r r. �all_keysr/ �key� criterion�p�pkeyr$ r, r* � _build_result& s4 � � �r< c @ s� e Zd ZdZdBdd �ZedCd d ��ZdDd d�ZdEdd�ZdFdd�Z dGd d �Z dHd#d$�Z dId'd(�Z dJd*d+�Z dKd.d/�ZdDd0d1�ZdDd2d3�ZdLd6d7�ZdMd9d:�ZdNd?d@�ZdAS )O� Resolutionz�Stateful resolution object. This is designed as a one-off object that holds information to kick start the resolution process, and holds the results afterwards. �provider� AbstractProvider[RT, CT, KT]�reporter�BaseReporter[RT, CT, KT]r" �Nonec C s( || _ || _g | _t| _d | _d | _d S �N)�_p�_r�_statesr � _optimistic_backjumping_ratio� _save_statesZ_optimistic_start_round)�selfr> r@ r$ r$ r* �__init__K s zResolution.__init__r! c C s0 z| j d W S ty } ztd�|�d }~ww )N���r )rF � IndexError�AttributeError)rI �er$ r$ r* r Y s ��zResolution.statec C s> | j d }t|j�� |j�� |jdd� d�}| j �|� dS )z�Push a new state into history. This new state will be used to hold resolution results of the next coming round. rK N�r. r0 �backtrack_causes)rF r r. �copyr0 rP �append)rI �baser r$ r$ r* �_push_new_state` s �zResolution._push_new_stater0 �dict[KT, Criterion[RT, CT]]� requirementr �parent� CT | Nonec C s� | j j||d� | jj|d�}|�|�}|r t|j�}ng }| jj|t|t � d�||gi�t|t � d�||i�d�}|rJt|j �}|� t||�� nt||�g}tt|�||d�}|js`t|��|||< d S )N)rV rW )Zrequirement_or_candidate�iter_requirement�incompatibilities�� identifier� requirementsrZ �� candidates� informationrZ )rE Zadding_requirementrD �identify�get�listrZ � find_matchesr �operator� methodcaller� attrgetterr` rR r r r r_ r ) rI r0 rV rW r\ r9 rZ �matchesr` r$ r$ r* �_add_to_criterian s> ��� � zResolution._add_to_criteria�parents�Collection[KT]c sD � sdS |� � D ]\}}t|j� �fdd�|jD �|j�||< qdS )aW Remove information from parents of criteria. Concretely, removes all values from each criterion's ``information`` field that have one of ``parents`` as provider of the requirement. :param criteria: The criteria to update. :param parents: Identifiers for which to remove information from all criteria. Nc s, g | ]}|j d u s�j�|j �� vr|�qS rC )rW rD ra )r' r` �rj rI r$ r* � <listcomp>� s �z@Resolution._remove_information_from_criteria.<locals>.<listcomp>)r1 r r_ r` rZ )rI r0 rj r8 r9 r$ rl r* �!_remove_information_from_criteria� s � ��z,Resolution._remove_information_from_criteria�namer r c C s> | j j|| jjt| jjt�d��t| jjt�d��| jjd�S )Nr_ r` )r\ � resolutionsr_ r` rP ) rD Zget_preferencer r. r r0 re rg rP )rI ro r$ r$ r* �_get_preference� s ���zResolution._get_preferencer9 �Criterion[RT, CT]�boolc sB z�j j| � W n ty Y dS w t� �fdd�|�� D ��S )NFc 3 � � | ] }�j j|� d �V qdS �)rV � candidateN�rD Zis_satisfied_by�r' �r�Z current_pinrI r$ r* � <genexpr>� � � � �z8Resolution._is_current_pin_satisfying.<locals>.<genexpr>)r r. r5 �allrY )rI ro r9 r$ rz r* �_is_current_pin_satisfying� s ��z%Resolution._is_current_pin_satisfyingrv r c C s4 | j j�� }| jj|d�D ] }| j|||d� q |S )N�rv �rW )r r0 rQ rD �get_dependenciesri )rI rv r0 rV r$ r$ r* �_get_updated_criteria� s z Resolution._get_updated_criteria�list[Criterion[RT, CT]]c s� �j j| }g }|jD ]^� z��� �}W n ty4 } z�j�|j� � |�|j� W Y d }~q d }~ww t � �fdd�|� � D ��}|sJt � |���jj � d� �j j� |� �j j�|d � � �j j|< g S |S )Nc 3 rt ru rw rx �rv rI r$ r* r{ � r| z7Resolution._attempt_to_pin_criterion.<locals>.<genexpr>r )r r0 r_ r� r rE Zrejecting_candidater9 rR r} rY r Zpinning�updater. �pop)rI ro r9 �causesr0 rN Z satisfiedr$ r� r* �_attempt_to_pin_criterion� s, �� � z$Resolution._attempt_to_pin_criterion� incompatibilities_from_broken�list[tuple[KT, list[CT]]]c C s� |D ]R\}}|s qz| j j| }W n ty Y qw | jj|t| j jt�d��t| j jt�d�||i�d�}t |�}|s@ dS |� |j � t |t |j�|d�| j j|< qdS )NrY rZ r[ Fr^ T)r r0 r5 rD rd r re rf rg r �extendrZ r rc r` )rI r� r( rZ r9 rh r_ r$ r$ r* �_patch_criteria� s< ���� �zResolution._patch_criteriac C s$ | j du rdd� | jD �| _ dS dS )zCSave states for potential rollback if optimistic backjumping fails.Nc S s0 g | ]}t |j�� |j�� |jd d � d��qS )NrO )r r. rQ r0 rP )r' �sr$ r$ r* rm ! s � ��z*Resolution._save_state.<locals>.<listcomp>)rH rF �rI r$ r$ r* � _save_state s ��zResolution._save_statec C s" d| _ | jr| j| _d| _dS dS )z3Rollback states and disable optimistic backjumping.g N)rG rH rF r� r$ r$ r* �_rollback_states* s �zResolution._rollback_statesr� �$list[RequirementInformation[RT, CT]]c s: t �dd� |D �dd� |D ��}� fdd�|D �}t� j�dkr�� jd= � j} z� j�� }|j�� \}}W n tt fyD t |�d �w � j sM||vrMn(� j r]� j d u r]||vr]� � � � fd d�� j�|�D �}|�|�spn|jstnq(d d � |j�� D �}|�||gf� � �� � �|�} | r�dS t� j�dks d S )a2 Perform backjumping. When we enter here, the stack is like this:: [ state Z ] [ state Y ] [ state X ] .... earlier states are irrelevant. 1. No pins worked for Z, so it does not have a pin. 2. We want to reset state Y to unpinned, and pin another candidate. 3. State X holds what state Y was before the pin, but does not have the incompatibility information gathered in state Y. Each iteration of the loop will: 1. Identify Z. The incompatibility is not always caused by the latest state. For example, given three requirements A, B and C, with dependencies A1, B1 and C1, where A1 and B1 are incompatible: the last state might be related to C, so we want to discard the previous state. 2. Discard Z. 3. Discard Y but remember its incompatibility information gathered previously, and the failure we're dealing with right now. 4. Push a new state Y' based on X, and apply the incompatibility information from Y to Y'. 5a. If this causes Y' to conflict, we need to backtrack again. Make Y' the new Z and go back to step 2. 5b. If the incompatibilities apply cleanly, end backtracking. c s s � | ] }|j d ur|j V qd S rC r� �r' �cr$ r$ r* r{ Q s � z'Resolution._backjump.<locals>.<genexpr>c s s � | ]}|j V qd S rC )rV r� r$ r$ r* r{ R s � c � h | ]}� j �|��qS r$ �rD ra rx r� r$ r* � <setcomp>T s z'Resolution._backjump.<locals>.<setcomp>� rK TNc r� r$ r� )r' �dr� r$ r* r� w s �c S s g | ] \}}|t |j�f�qS r$ )rc rZ r& r$ r$ r* rm � s �z(Resolution._backjump.<locals>.<listcomp>F)� itertools�chain�lenrF r r� r. �popitemrL r5 r rG rH r� rD r� � isdisjointr0 r1 rR rT r� ) rI r� Zincompatible_reqsZincompatible_depsZ broken_statero rv Zcurrent_dependenciesr� �successr$ r� r* � _backjump1 sT � ��� � �(� �@zResolution._backjump�criteronc C s t dd� |D ��� �S )z5Extract causes from list of criterion and deduplicatec S s" i | ] }|j D ]}t|�|�qqS r$ )r` r% )r' r� �ir$ r$ r* r+ � s " z.Resolution._extract_causes.<locals>.<dictcomp>)rc �values)rI r� r$ r$ r* �_extract_causes� s zResolution._extract_causesr] � Iterable[RT]� max_rounds�intc s� �j rtd���j�� tt�� i g d�g�_ |D ]!}z �j�jj |d d� W q t y: } zt |j j �|�d }~ww ��� d }d }t|�D �]#}�jj|d� �jr��jd ur�|d u rr|}t|| �j �}|dkrq��� qGn|d ur�|| |kr���� qG�fdd��jj �� D �}|s��jj�jd� �j S t�jj �� �t|� � t|�d kr�t�jj |�jj t �jj t � d ��t �jj t � d ���jj!d ��} n|} | s�td ��t| �d kr�t"| �j#d�} n| d } ��$| �} | �rH��%| �} �jj&| d� z��'| �} W n t �y �j�r�j�rd}n� Y nw t(| �o(�j�o(�j�}|�r6�j�r6��� n,| �jj!d d �< | �sGt �jj!��n� �fdd��jj �� D �}��)�jj |� ��� �jj*|�jd� qGt+|��)Nzalready resolvedrO r� )�indexr c s g | ] \}}� � ||�s|�qS r$ �r~ �r' r8 r9 r� r$ r* rm � s ��z&Resolution.resolve.<locals>.<listcomp>)r r r_ r` )Z identifiersrp r_ r` rP z-narrow_requirement_selection returned 0 names)r8 )r� Tc s( h | ]\}}|� v r�� ||�s|�qS r$ r� r� �Zsatisfied_namesrI r$ r* r� s ��z%Resolution.resolve.<locals>.<setcomp>)r� r ),rF � RuntimeErrorrE Zstartingr � collections� OrderedDictri r r0 r r r9 r` rT �rangeZstarting_roundrG rH r� r� r1 Zending�set�keysr� rc rD Z narrow_requirement_selectionr. r re rg rP �minrq r� r� Zresolving_conflictsr� rs rn Z ending_roundr )rI r] r� ry rN Zoptimistic_rounds_cutoffZ"optimistic_backjumping_start_roundZ round_indexZunsatisfied_namesZnarrowed_unstatisfied_namesro Zfailure_criterionr� r� Z failed_optimistic_backjumpingZnewly_unsatisfied_namesr$ r� r* �resolve� s� ���� ��� � ���� ���� � ��zResolution.resolveN)r> r? r@ rA r" rB )r" r! )r" rB )r0 rU rV r rW rX r" rB )r0 rU rj rk r" rB )ro r r" r )ro r r9 rr r" rs )rv r r" rU )ro r r" r� )r� r� r" rs )r� r� r" rs )r� r� r" r� )r] r� r� r� r" r! )�__name__� __module__� __qualname__�__doc__rJ �propertyr rT ri rn rq r~ r� r� r� r� r� r� r� r� r$ r$ r$ r* r= D s$ , % # fr= c @ s" e Zd ZdZeZ d d d d �Zd S )�Resolverz3The thing that performs the actual resolution work.�d r] r� r� r� r" r# c C s$ t | j| j�}|j||d�}t|�S )a Take a collection of constraints, spit out the resolution result. The return value is a representation to the final resolution result. It is a tuple subclass with three public members: * `mapping`: A dict of resolved candidates. Each key is an identifier of a requirement (as returned by the provider's `identify` method), and the value is the resolved candidate. * `graph`: A `DirectedGraph` instance representing the dependency tree. The vertices are keys of `mapping`, and each edge represents *why* a particular package is included. A special vertex `None` is included to represent parents of user-supplied requirements. * `criteria`: A dict of "criteria" that hold detailed information on how edges in the graph are derived. Each key is an identifier of a requirement, and the value is a `Criterion` instance. The following exceptions may be raised if a resolution cannot be found: * `ResolutionImpossible`: A resolution cannot be found for the given combination of requirements. The `causes` attribute of the exception is a list of (requirement, parent), giving the requirements that could not be satisfied. * `ResolutionTooDeep`: The dependency tree is too deeply nested and the resolver gave up. This is usually caused by a circular dependency, but you can try to resolve this by increasing the `max_rounds` argument. )r� )r= r> r@ r� r< )rI r] r� � resolutionr r$ r$ r* r� 3 s zResolver.resolveN)r� )r] r� r� r� r" r# )r� r� r� r� r Zbase_exceptionr� r$ r$ r$ r* r� . s �r� r0 � Mapping[KT, Criterion[RT, CT]]r8 � KT | Noner7 �dict[int, KT | None]r- �set[KT | None]rs c C s� ||v rdS || vr dS |d usJ �| | � � D ]/}z|t|� }W n ty+ Y qw ||v r8|�|� dS t| |||�rG|�|� dS qdS )NTF)r4 r% r5 r2 r3 )r0 r8 r7 r- r: r; r$ r$ r* r3 X s& � �r3 )r r! r" r# ) r0 r� r8 r� r7 r� r- r� r" rs ),� __future__r r� r� re �typingr r �structsr r r r r r r r r Zabstractr r r9 r � exceptionsr r r r r �collections.abcr r r Z providersr r Z reportersr r �__annotations__r< r= r� r3 r$ r$ r$ r* �<module> s* , m*
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings