Файловый менеджер - Редактировать - /home/skymarketplace/public_html/uploads/resolvelib.tar
Назад
__init__.py 0000644 00000001031 15004442445 0006652 0 ustar 00 __all__ = [ "__version__", "AbstractProvider", "AbstractResolver", "BaseReporter", "InconsistentCandidate", "Resolver", "RequirementsConflicted", "ResolutionError", "ResolutionImpossible", "ResolutionTooDeep", ] __version__ = "1.0.1" from .providers import AbstractProvider, AbstractResolver from .reporters import BaseReporter from .resolvers import ( InconsistentCandidate, RequirementsConflicted, ResolutionError, ResolutionImpossible, ResolutionTooDeep, Resolver, ) __pycache__/__init__.cpython-311.pyc 0000644 00000001405 15004442445 0013217 0 ustar 00 � ]�bg � �N � g d �Z dZddlmZmZ ddlmZ ddlmZm Z m Z m Z m Z m Z dS )) � __version__�AbstractProvider�AbstractResolver� BaseReporter�InconsistentCandidate�Resolver�RequirementsConflicted�ResolutionError�ResolutionImpossible�ResolutionTooDeepz1.0.1� )r r )r )r r r r r r N)�__all__r � providersr r � reportersr � resolversr r r r r r � � �p/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/__init__.py�<module>r s� �� � � �� � � :� 9� 9� 9� 9� 9� 9� 9� #� #� #� #� #� #�� � � � � � � � � � � � � � � � � r __pycache__/providers.cpython-311.pyc 0000644 00000015663 15004442445 0013510 0 ustar 00 � ]�bg� � �> � G d � de � � Z G d� de � � ZdS )c �0 � e Zd ZdZd� Zd� Zd� Zd� Zd� ZdS )�AbstractProviderzBDelegate class to provide the required interface for the resolver.c � � t �)z�Given a requirement, return an identifier for it. This is used to identify a requirement, e.g. whether two requirements should have their specifier parts merged. ��NotImplementedError)�self�requirement_or_candidates �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/providers.py�identifyzAbstractProvider.identify � � � "�!� c � � t �)a� Produce a sort key for given requirement based on preference. The preference is defined as "I think this requirement should be resolved first". The lower the return value is, the more preferred this group of arguments is. :param identifier: An identifier as returned by ``identify()``. This identifies the dependency matches which should be returned. :param resolutions: Mapping of candidates currently pinned by the resolver. Each key is an identifier, and the value is a candidate. The candidate may conflict with requirements from ``information``. :param candidates: Mapping of each dependency's possible candidates. Each value is an iterator of candidates. :param information: Mapping of requirement information of each package. Each value is an iterator of *requirement information*. :param backtrack_causes: Sequence of requirement information that were the requirements that caused the resolver to most recently backtrack. A *requirement information* instance is a named tuple with two members: * ``requirement`` specifies a requirement contributing to the current list of candidates. * ``parent`` specifies the candidate that provides (depended on) the requirement, or ``None`` to indicate a root requirement. The preference could depend on various issues, including (not necessarily in this order): * Is this package pinned in the current resolution result? * How relaxed is the requirement? Stricter ones should probably be worked on first? (I don't know, actually.) * How many possibilities are there to satisfy this requirement? Those with few left should likely be worked on first, I guess? * Are there any known conflicts for this requirement? We should probably work on those with the most known conflicts. A sortable value should be returned (this will be used as the ``key`` parameter of the built-in sorting function). The smaller the value is, the more preferred this requirement is (i.e. the sorting function is called with ``reverse=False``). r )r � identifier� resolutions� candidates� information�backtrack_causess r �get_preferencez AbstractProvider.get_preference s � �b "�!r c � � t �)a� Find all possible candidates that satisfy the given constraints. :param identifier: An identifier as returned by ``identify()``. This identifies the dependency matches of which should be returned. :param requirements: A mapping of requirements that all returned candidates must satisfy. Each key is an identifier, and the value an iterator of requirements for that dependency. :param incompatibilities: A mapping of known incompatibilities of each dependency. Each key is an identifier, and the value an iterator of incompatibilities known to the resolver. All incompatibilities *must* be excluded from the return value. This should try to get candidates based on the requirements' types. For VCS, local, and archive requirements, the one-and-only match is returned, and for a "named" requirement, the index(es) should be consulted to find concrete candidates for this requirement. The return value should produce candidates ordered by preference; the most preferred candidate should come first. The return type may be one of the following: * A callable that returns an iterator that yields candidates. * An collection of candidates. * An iterable of candidates. This will be consumed immediately into a list of candidates. r )r r � requirements�incompatibilitiess r � find_matchesz AbstractProvider.find_matches? s � �6 "�!r c � � t �)a Whether the given requirement can be satisfied by a candidate. The candidate is guaranteed to have been generated from the requirement. A boolean should be returned to indicate whether ``candidate`` is a viable solution to the requirement. r )r � requirement� candidates r �is_satisfied_byz AbstractProvider.is_satisfied_by\ s � � "�!r c � � t �)z�Get dependencies of a candidate. This should return a collection of requirements that `candidate` specifies as its dependencies. r )r r s r �get_dependenciesz!AbstractProvider.get_dependenciesg r r N) �__name__� __module__� __qualname__�__doc__r r r r r � r r r r sf � � � � � �L�L�"� "� "�1"� 1"� 1"�f"� "� "�: "� "� "�"� "� "� "� "r r c �" � e Zd ZdZeZd� Zd� ZdS )�AbstractResolverz3The thing that performs the actual resolution work.c �" � || _ || _ d S )N)�provider�reporter)r r& r' s r �__init__zAbstractResolver.__init__u s � � �� � �� � � r c � � t �)a� Take a collection of constraints, spit out the resolution result. This returns a representation of the final resolution state, with one guarenteed attribute ``mapping`` that contains resolved candidates as values. The keys are their respective identifiers. :param requirements: A collection of constraints. :param kwargs: Additional keyword arguments that subclasses may accept. :raises: ``self.base_exception`` or its subclass. r )r r �kwargss r �resolvezAbstractResolver.resolvey s � � "�!r N)r r r r! � Exception�base_exceptionr( r+ r" r r r$ r$ p s= � � � � � �=�=� �N�!� !� !� "� "� "� "� "r r$ N)�objectr r$ r" r r �<module>r/ sl ��l"� l"� l"� l"� l"�v� l"� l"� l"�^"� "� "� "� "�v� "� "� "� "� "r __pycache__/reporters.cpython-311.pyc 0000644 00000005447 15004442445 0013517 0 ustar 00 � ]�bgA � �" � G d � de � � ZdS )c �B � e Zd ZdZd� Zd� Zd� Zd� Zd� Zd� Z d� Z d � Z d S ) � BaseReporterz?Delegate class to provider progress reporting for the resolver.c � � dS )z-Called before the resolution actually starts.N� )�selfs �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/reporters.py�startingzBaseReporter.starting � � � � � c � � dS )zYCalled before each round of resolution starts. The index is zero-based. Nr )r �indexs r �starting_roundzBaseReporter.starting_round r r c � � dS )z�Called before each round of resolution ends. This is NOT called if the resolution ends at this round. Use `ending` if you want to report finalization. The index is zero-based. Nr )r r �states r � ending_roundzBaseReporter.ending_round r r c � � dS )z/Called before the resolution ends successfully.Nr )r r s r �endingzBaseReporter.ending r r c � � dS )a� Called when adding a new requirement into the resolve criteria. :param requirement: The additional requirement to be applied to filter the available candidaites. :param parent: The candidate that requires ``requirement`` as a dependency, or None if ``requirement`` is one of the root requirements passed in from ``Resolver.resolve()``. Nr )r � requirement�parents r �adding_requirementz BaseReporter.adding_requirement r r c � � dS )z�Called when starting to attempt requirement conflict resolution. :param causes: The information on the collision that caused the backtracking. Nr )r �causess r �resolving_conflictsz BaseReporter.resolving_conflicts! r r c � � dS )z6Called when rejecting a candidate during backtracking.Nr )r � criterion� candidates r �rejecting_candidatez BaseReporter.rejecting_candidate' r r c � � dS )z9Called when adding a candidate to the potential solution.Nr )r r s r �pinningzBaseReporter.pinning* r r N) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r r r r s� � � � � � �I�I�<� <� <� � � � � � �>� >� >� � � � � � � E� E� E�H� H� H� H� Hr r N)�objectr r r r �<module>r% sC ��*H� *H� *H� *H� *H�6� *H� *H� *H� *H� *Hr __pycache__/resolvers.cpython-311.pyc 0000644 00000071107 15004442445 0013512 0 ustar 00 � ]�bg P � � � d dl Z d dlZd dlZddlmZ ddlmZmZmZ e j dddg� � Z G d� d e � � Z G d � d e � � Z G d � d e � � Z G d� de� � Z G d� de � � Z G d� de� � Z G d� de� � Z e j dd� � Z G d� de� � Zd� Z e j dd � � Zd � Z G d � d e� � ZdS ) � N� )�AbstractResolver)� DirectedGraph�IteratorMapping�build_iter_view�RequirementInformation� requirement�parentc � � e Zd ZdZdS )�ResolverExceptionz�A base class for all exceptions raised by this module. Exceptions derived by this class should all be handled in this module. Any bubbling pass the resolver should be treated as a bug. N)�__name__� __module__� __qualname__�__doc__� � �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/resolvers.pyr r s � � � � � �� � � r r c �$ � � e Zd Z� fd�Zd� Z� xZS )�RequirementsConflictedc �f �� t t | � � � |� � || _ d S �N)�superr �__init__� criterion)�selfr � __class__s �r r z RequirementsConflicted.__init__ s- �� � �$�d�+�+�4�4�Y�?�?�?�"����r c � � d� d� d� | j � � � D � � � � � � S )NzRequirements conflict: {}�, c 3 �4 K � | ]}t |� � V � �d S r ��repr��.0�rs r � <genexpr>z1RequirementsConflicted.__str__.<locals>.<genexpr> �( � � � �I�I�!�d�1�g�g�I�I�I�I�I�Ir )�format�joinr �iter_requirement�r s r �__str__z RequirementsConflicted.__str__ sF � �*�1�1� �I�I�I�I�t�~�'F�'F�'H�'H�I�I�I� I� I� � � r �r r r r r+ � __classcell__�r s @r r r sG �� � � � � �#� #� #� #� #� � � � � � � r r c �$ � � e Zd Z� fd�Zd� Z� xZS )�InconsistentCandidatec �v �� t t | � � � ||� � || _ || _ d S r )r r0 r � candidater )r r2 r r s �r r z InconsistentCandidate.__init__! s6 �� � �#�T�*�*�3�3�I�y�I�I�I�"���"����r c � � d� | j d� d� | j � � � D � � � � � � S )Nz+Provided candidate {!r} does not satisfy {}r c 3 �4 K � | ]}t |� � V � �d S r r r" s r r% z0InconsistentCandidate.__str__.<locals>.<genexpr>) r& r )r' r2 r( r r) r* s r r+ z InconsistentCandidate.__str__& sK � �<�C�C� �N� �I�I�I�I�t�~�'F�'F�'H�'H�I�I�I� I� I� � � r r, r. s @r r0 r0 sG �� � � � � �#� #� #� #� #� � � � � � � r r0 c �* � e Zd ZdZd� Zd� Zd� Zd� ZdS )� CriterionaQ Representation of possible resolution results of a package. This holds three attributes: * `information` is a collection of `RequirementInformation` pairs. Each pair is a requirement contributing to this criterion, and the candidate that provides the requirement. * `incompatibilities` is a collection of all known not-to-work candidates to exclude from consideration. * `candidates` is a collection containing all possible candidates deducted from the union of contributing requirements and known incompatibilities. It should never be empty, except when the criterion is an attribute of a raised `RequirementsConflicted` (in which case it is always empty). .. note:: This class is intended to be externally immutable. **Do not** mutate any of its attribute containers. c �0 � || _ || _ || _ d S r �� candidates� information�incompatibilities)r r9 r: r; s r r zCriterion.__init__A s � �$���&���!2�� � � r c �t � d� d� | j D � � � � }d� |� � S )Nr c 3 �H K � | ] \ }}d � ||� � V � � dS )z({!r}, via={!r})N)r' )r# �reqr s r r% z%Criterion.__repr__.<locals>.<genexpr>G sJ � � � � ! � ! ���V� � %� %�c�6� 2� 2�! � ! � ! � ! � ! � ! r z Criterion({}))r( r: r' )r � requirementss r �__repr__zCriterion.__repr__F sJ � ��y�y� ! � ! � #� /�! � ! � ! � � � � �%�%�l�3�3�3r c �$ � d� | j D � � S )Nc 3 �$ K � | ] }|j V � � d S r �r �r# �is r r% z-Criterion.iter_requirement.<locals>.<genexpr>N s$ � � � �8�8�!�� �8�8�8�8�8�8r �r: r* s r r) zCriterion.iter_requirementM s � �8�8�t�'7�8�8�8�8r c �$ � d� | j D � � S )Nc 3 �$ K � | ] }|j V � � d S r �r rD s r r% z(Criterion.iter_parent.<locals>.<genexpr>Q s$ � � � �3�3�Q���3�3�3�3�3�3r rF r* s r � iter_parentzCriterion.iter_parentP s � �3�3�$�"2�3�3�3�3r N)r r r r r r@ r) rJ r r r r6 r6 - sZ � � � � � �� �&3� 3� 3� 4� 4� 4�9� 9� 9�4� 4� 4� 4� 4r r6 c � � e Zd ZdS )�ResolutionErrorN)r r r r r r rL rL T s � � � � � ��Dr rL c � � � e Zd Z� fd�Z� xZS )�ResolutionImpossiblec �f �� t t | � � � |� � || _ d S r )r rN r �causes)r rP r s �r r z ResolutionImpossible.__init__Y s- �� � �"�D�)�)�2�2�6�:�:�:� �� � � r �r r r r r- r. s @r rN rN X s8 �� � � � � � � � � � � � � � r rN c � � � e Zd Z� fd�Z� xZS )�ResolutionTooDeepc �f �� t t | � � � |� � || _ d S r )r rS r � round_count)r rU r s �r r zResolutionTooDeep.__init__` s0 �� � � ��&�&�/�/� �<�<�<�&����r rQ r. s @r rS rS _ s8 �� � � � � �'� '� '� '� '� '� '� '� 'r rS �Statez!mapping criteria backtrack_causesc �d � e Zd ZdZd� Zed� � � Zd� Zd� Zd� Z d� Z d� Z d � Z d � Z d � Zd � Zd S )� 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. c �0 � || _ || _ g | _ d S r )�_p�_r�_states)r �provider�reporters r r zResolution.__init__p s � ��������� � � r c �X � | j d S # t $ r t d� � �w xY w)N����state)r\ � IndexError�AttributeErrorr* s r ra zResolution.stateu s= � � *��<��#� #��� *� *� *� ��)�)� )� *���s � �)c �� � | j d }t |j � � � |j � � � |j dd� �� � }| j � |� � dS )z�Push a new state into history. This new state will be used to hold resolution results of the next coming round. r` N��mapping�criteria�backtrack_causes)r\ rV rf �copyrg rh �append)r �basera s r �_push_new_statezResolution._push_new_state| ss � � �|�B� ����L�%�%�'�'��]�'�'�)�)� !� 2�1�1�1� 5� � � �� � ���E�"�"�"�"�"r c � � | j � ||�� � | j � |�� � }|� |� � }|rt |j � � }ng }| j � |t |t j d� � ||gi� � t |t j d� � ||i� � �� � }|r8t |j � � }|� t ||� � � � nt ||� � g}t t! |� � ||�� � }|j st% |� � �|||< d S )N)r r )�requirement_or_candidater) r; �� identifierr? r; r8 )r[ �adding_requirementrZ �identify�get�listr; � find_matchesr �operator� methodcaller� attrgetterr: rj r r6 r r9 r ) r rg r r rp r r; �matchesr: s r �_add_to_criteriazResolution._add_to_criteria� sy � � ��"�"�{�6�"�J�J�J��W�%�%�{�%�K�K� � �L�L��,�,� � � #� $�Y�%@� A� A� � � "� ��'�&�&�!�(���%�&8�9�9��k�]�+�� � .���#�$7�8�8�� .�/� � � '� � �� � H� �y� 4�5�5�K� � � � 5�k�6� J� J� K� K� K� K�1�+�v�F�F�G�K� �&�w�/�/�#� /� � � � � �#� 4�(��3�3� 3� (��� � � r c � � �� �sdS |� � � D ]5\ }}t |j �� fd�|j D � � |j � � ||< �6dS )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 �d �� g | ],}|j �!�j � |j � � �v�*|��-S r )r rZ rr )r# r: �parentsr s ��r � <listcomp>z@Resolution._remove_information_from_criteria.<locals>.<listcomp>� sM �� � � � �#�#�*�2� �7�+�+�K�,>�?�?�w�N�N� � O�N�Nr )�itemsr6 r9 r: r; )r rg r} �keyr s ` ` r �!_remove_information_from_criteriaz,Resolution._remove_information_from_criteria� s� ��� � � � �F� &�n�n� .� .� � �N�C�� %��$�� � � � �'0�'<�� � � �+� � �H�S�M�M� � r c � � | j � || j j t | j j t j d� � � � t | j j t j d� � � � | j j �� � S )Nr9 r: )rp � resolutionsr9 r: rh ) rZ �get_preferencera rf r rg rv rx rh )r �names r �_get_preferencezResolution._get_preference� s~ � ��w�%�%�� � �*�&�� �#��#�L�1�1�� � (�� �#��#�M�2�2�� � "�Z� 8� &� � � r c � � �� � j j | �n# t $ r Y dS w xY wt �� fd�|� � � D � � � � S )NFc 3 �P �K � | ] }�j � |�� � � V � �!dS �)r r2 N�rZ �is_satisfied_by)r# r$ � current_pinr s ��r r% z8Resolution._is_current_pin_satisfying.<locals>.<genexpr>� sL �� � � � � �� �G� #� #��[� #� I� I� � � � � � r )ra rf �KeyError�allr) )r r� r r� s ` @r �_is_current_pin_satisfyingz%Resolution._is_current_pin_satisfying� s� ��� � � �*�,�T�2�K�K��� � � ��5�5� ����� � � � � � �/�/�1�1� � � � � � s � � %�%c � � | j j � � � }| j � |�� � D ]}| � |||�� � �|S )N�r2 rI )ra rg ri rZ �get_dependenciesrz )r r2 rg r s r �_get_updated_criteriaz Resolution._get_updated_criteria� s_ � ��:�&�+�+�-�-�� �7�3�3�i�3�H�H� K� K�K� � !� !�(�K� � !� J� J� J� J��r c �p � �� � j j | }g }|j D �]� � � �� � }nQ# t $ rD}� j � |j �� � |� |j � � Y d }~�cd }~ww xY wt �� fd�|� � � D � � � � }|st �|� � �� j � ��� � � j j � |� � � j j � |d � � �� j j |< g c S |S )Nc 3 �P �K � | ] }�j � |�� � � V � �!dS r� r� )r# r$ r2 r s ��r r% z7Resolution._attempt_to_pin_criterion.<locals>.<genexpr>� sL �� � � � � �� ��'�'�A��'�K�K� � � � � � r r� )ra rg r9 r� r r[ �rejecting_candidater rj r� r) r0 �pinning�updaterf �pop)r r� r rP rg �e� satisfiedr2 s ` @r �_attempt_to_pin_criterionz$Resolution._attempt_to_pin_criterion� sj ��� ��J�'��-� ���"�-� � �I� � �5�5�i�@�@����)� � � ���+�+�A�K��C�C�C�� � �a�k�*�*�*���������� ���� � � � � � �"�3�3�5�5� � � � � �I� � B�+�I�y�A�A�A� �G�O�O�i�O� 0� 0� 0� �J� � &� &�x� 0� 0� 0� �J� � "� "�4�� .� .� .�'0�D�J� �t� $��I�I�I� � s �8� B�:B�Bc �� � � � t j d� |D � � d� |D � � � � }� fd�|D � � }t � j � � dk �r!� j d= d}|s� � j � � � }|j � � � \ }}n$# t t f$ r t |� � �w xY w� fd�� j � |� � D � � }|� |� � }|��d� |j � � � D � � � � � ||gf� � � � fd �} � � � � | � � } | rd S t � j � � dk ��!dS ) 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 3 �2 K � | ]}|j � |j V � �d S r rI �r# �cs r r% z'Resolution._backjump.<locals>.<genexpr>. s+ � � � � >� >�!���)=�Q�X�)=�)=�)=�)=� >� >r c 3 �$ K � | ] }|j V � � d S r rC r� s r r% z'Resolution._backjump.<locals>.<genexpr>/ s$ � � � � +� +�q�Q�]� +� +� +� +� +� +r c �D �� h | ] }�j � |� � �� S r �rZ rr )r# r$ r s �r � <setcomp>z'Resolution._backjump.<locals>.<setcomp>1 s) �� � L� L� L�Q�T�W� -� -�a� 0� 0� L� L� Lr � r` Fc �D �� h | ] }�j � |� � �� S r r� )r# �dr s �r r� z'Resolution._backjump.<locals>.<setcomp>? s9 �� � (� (� (�� �G�$�$�Q�'�'�(� (� (r c �@ � g | ]\ }}|t |j � � f�� S r )rt r; �r# �k�vs r r~ z(Resolution._backjump.<locals>.<listcomp>G s< � � -� -� -��A�q� �D��,�-�-�.�-� -� -r c � �� �D �] \ } }|s� �j j | }n# t $ r Y �)w xY w�j � | t �j j t j d� � � � t �j j t j d� � | |i� � �� � }t |� � }|s dS |� |j � � t |t |j � � |�� � �j j | < ��dS )Nr) r; ro Fr8 T)ra rg r� rZ ru r rv rw rx r �extendr; r6 rt r: )r� r; r ry r9 � incompatibilities_from_brokenr s ��r �_patch_criteriaz-Resolution._backjump.<locals>._patch_criteriaQ s< �� �,I� � �(�A�(�,� !� �!�$(�J�$7��$:� � ��#� !� !� !� ��!���� "�g� 2� 2�#$�%4� �J� /� $� 1�2D� E� E�&� &� +:� �J� /� $� /�0C� D� D� � 1� 2�+� +� 3� � �G� "1��!9�!9�J�%� %� $�u�u�%�,�,�Y�-H�I�I�I�-6�#-�$(��)>�$?�$?�*;�.� .� .�D�J�'��*�*� �ts �!� .�.T)� itertools�chain�lenr\ r� rf �popitemrb r� rN rZ r� � isdisjointrg r rj rl ) r rP �incompatible_reqs�incompatible_deps�incompatible_state� broken_stater� r2 �current_dependenciesr� �successr� s ` @r � _backjumpzResolution._backjump s ��� �> &�O� >� >�v� >� >� >� +� +�F� +� +� +� � �� M� L� L� L�:K� L� L� L���$�,� � �1�$�$�� �R� � "'� �(� �7�#'�<�#3�#3�#5�#5�L�&2�&:�&B�&B�&D�&D�O�D�)�)��"�H�-� 7� 7� 7�.�v�6�6�6�7����(� (� (� (� !�W� 5� 5�i� @� @�(� (� (�$� *>�)H�)H�%�*� *� &�"� )� � -� -� (� 1� 7� 7� 9� 9�-� -� -� )� *� 0� 0�$�� �1D� E� E� E� � � � � � �> � � � "� "� "�%�o�'�'�G� � ��t�G �$�,� � �1�$�$�R �us � 5B �!B7c �L � � � � j rt d� � �� j � � � t t j � � i g �� � g� _ |D ]P} � � � j j |d �� � �&# t $ r }t |j j � � �d }~ww xY w� � � � t |� � D �]�}� j � |�� � � fd�� j j � � � D � � }|s)� j � � j �� � � j c S t' � j j � � � � � t' |� � z � t+ |� j �� � }� � |� � }|rid� |D � � } � j � | � � � � � | � � } | � j j d d �< | st � j j � � �n_� � fd �� j j � � � D � � } � � � j j | � � � � � � � j � |� j � � � ���t; |� � �) Nzalready resolvedre rI )�indexc �F �� g | ] \ }}�� ||� � �|�� S r �r� )r# r� r r s �r r~ z&Resolution.resolve.<locals>.<listcomp>� sC �� � !� !� !�"�C���6�6�s�I�F�F�!��!� !� !r )ra )r� c �& � g | ]}|j D ]}|���S r rF )r# r� rE s r r~ z&Resolution.resolve.<locals>.<listcomp>� s' � �K�K�K��Q�]�K�K��!�K�K�K�Kr )rP c �N �� h | ]!\ }}|�v � �� ||� � � |��"S r r� )r# r� r �satisfied_namesr s ��r r� z%Resolution.resolve.<locals>.<setcomp>� sJ �� � +� +� +�&��Y��o�-�-� � ;� ;�C�� K� K� .� �-�-�-r )r� ra ) r\ � RuntimeErrorr[ �startingrV � collections� OrderedDictrz ra rg r rN r r: rl �range�starting_roundr �ending�set�keys�minr� r� �resolving_conflictsr� rh r� � ending_roundrS ) r r? � max_roundsr$ r� � round_index�unsatisfied_namesr� �failure_causesrP r� �newly_unsatisfied_namesr� s ` @r �resolvezResolution.resolve} s ��� � �<� 3� � 1�2�2� 2� ������� �#�/�1�1��!#� � � � �� � � D� D�A� D��%�%�d�j�&9�1�T�%�J�J�J�J��)� D� D� D�*�1�;�+B�C�C�C����� D���� � � � � � � ��,�,� 1 F� 1 F�K� �G� "� "�� "� 5� 5� 5�!� !� !� !�&*�j�&9�&?�&?�&A�&A�!� !� !� � %� "�����T�Z��0�0�0��z�!�!�!� "�$�*�"5�":�":�"<�"<� =� =��!�A� A� �O� �(�d�.B�C�C�C�D� !� ;� ;�D� A� A�N� � '�K�K�^�K�K�K�� ��+�+�6�+�:�:�:� �.�.��0�0��17�� �+�A�A�A�.� � L�.�t�z�/J�K�K�K�L� +� +� +� +� +�*.�*�*=�*C�*C�*E�*E�+� +� +�'� �6�6��J�'�)@�� � � �$�$�&�&�&� �G� � �{�$�*� � E� E� E� E� � �+�+�+s � "B� B+� B&�&B+N)r r r r r �propertyra rl rz r� r� r� r� r� r� r� r r r rX rX i s� � � � � � �� � � � � �*� *� �X�*� #� #� #� %)� %)� %)�N� � �2 � � � � � �� � � #� #� #�Jm� m� m�^L,� L,� L,� L,� L,r rX c �2 � ||v rdS || vrdS | | � � � D ]o} |t |� � }n# t $ r Y �%w xY w||v r|� |� � dS t | |||� � r|� |� � dS �pdS )NTF)rJ �idr� �add�_has_route_to_root)rg r� �all_keys� connected�p�pkeys r r� r� � s� � � �i����t� �(����u� �c�]� &� &� (� (� � �� ��B�q�E�E�?�D�D��� � � � �H� ���� �9� � � �M�M�#� � � ��4�4� �h��h� � B� B� � �M�M�#� � � ��4�4� � �5s �A � A � A �Resultzmapping graph criteriac � �� | j }d� |� � � D � � }d |t d � � < t � � }|� d � � d h�| j � � � D ]�\ }}t | j ||�� � s� ||vr|� |� � |� � � D ]X} |t |� � }n# t $ r Y �%w xY w||vr|� |� � |� ||� � �Y��t �fd�|� � � D � � || j �� � S )Nc �4 � i | ]\ }}t |� � |��S r )r� r� s r � <dictcomp>z!_build_result.<locals>.<dictcomp>� s$ � �5�5�5�T�Q���1���q�5�5�5r c �$ �� i | ] \ }}|�v � ||�� S r r )r# r� r� r� s �r r� z!_build_result.<locals>.<dictcomp>� s$ �� �D�D�D�$�!�Q�Q�)�^�^��A�^�^�^r )rf �graphrg ) rf r r� r r� rg r� rJ r� �connectr� ) ra rf r� r� r� r r� r� r� s @r � _build_resultr� � sq �� ��m�G�5�5�W�]�]�_�_�5�5�5�H� �H�R��X�X�� �O�O�E� �I�I�d�O�O�O���I� �.�.�.�0�0� %� %���Y�!�%�.�#�x��K�K� � � �e� � � �I�I�c�N�N�N��&�&�(�(� %� %�A� � ��1�������� � � ��� �����5� � �� � �$���� �M�M�$�� $� $� $� $� %� �D�D�D�D�'�-�-�/�/�D�D�D��� � � � � s �C� C(�'C(c � � e Zd ZdZeZdd�ZdS )�Resolverz3The thing that performs the actual resolution work.�d c � � t | j | j � � }|� ||�� � }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� )rX r] r^ r� r� )r r? r� � resolutionra s r r� zResolver.resolve s= � �8 �� �t�}�=�=� ��"�"�<�J�"�G�G�� �U�#�#�#r N)r� )r r r r r �base_exceptionr� r r r r� r� s3 � � � � � �=�=�&�N� $� $� $� $� $� $r r� )r� r� rv � providersr �structsr r r � namedtupler � Exceptionr r r0 �objectr6 rL rN rS rV rX r� r� r� r� r r r �<module>r� sS �� � � � � � � � � ���� '� '� '� '� '� '� D� D� D� D� D� D� D� D� D� D�/��/� �}�h� 7�� � � � � � � � � � � � � � � � � .� � � � � � � � � -� � � �$4� $4� $4� $4� $4�� $4� $4� $4�N � � � � �'� � � � � � � � �?� � � �'� '� '� '� '�� '� '� '� � � �w�(K�L�L��`,� `,� `,� `,� `,�� `,� `,� `,�F � � �& �� ��*B� C� C��� � �<#$� #$� #$� #$� #$� � #$� #$� #$� #$� #$r __pycache__/structs.cpython-311.pyc 0000644 00000026344 15004442445 0013200 0 ustar 00 � ]�bgc � � � d dl Z ddlmZ G d� de� � Z G d� dej � � Z G d� d e� � Z G d � d e� � Zd � Z dS ) � N� )�collections_abcc �Z � e Zd ZdZd� Zd� Zd� Zd� Zd� Zd� Z d� Z d � Z d � Z d � Z d � Zd � ZdS )� DirectedGraphz&A graph structure with directed edges.c �H � t � � | _ i | _ i | _ d S �N)�set� _vertices� _forwards� _backwards��selfs �o/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/structs.py�__init__zDirectedGraph.__init__ s � � �������� ����� c �* � t | j � � S r )�iterr r s r �__iter__zDirectedGraph.__iter__ � � ��D�N�#�#�#r c �* � t | j � � S r )�lenr r s r �__len__zDirectedGraph.__len__ s � ��4�>�"�"�"r c � � || j v S r )r �r �keys r � __contains__zDirectedGraph.__contains__ s � ��d�n�$�$r c �� � t � � }t | j � � |_ d� | j � � � D � � |_ d� | j � � � D � � |_ |S )z$Return a shallow copy of this graph.c �4 � i | ]\ }}|t |� � ��S � �r ��.0�k�vs r � <dictcomp>z&DirectedGraph.copy.<locals>.<dictcomp> s$ � �H�H�H���A�1�c�!�f�f�H�H�Hr c �4 � i | ]\ }}|t |� � ��S r r r! s r r% z&DirectedGraph.copy.<locals>.<dictcomp> s$ � �J�J�J�$�!�Q�A�s�1�v�v�J�J�Jr )r r r r �itemsr )r �others r �copyzDirectedGraph.copy sh � � ���� �d�n�-�-���H�H�� �1E�1E�1G�1G�H�H�H���J�J�$�/�2G�2G�2I�2I�J�J�J���� r c �� � || j v rt d� � �| j � |� � t � � | j |< t � � | j |< dS )z Add a new vertex to the graph.z vertex existsN)r � ValueError�addr r r r s r r, zDirectedGraph.add sY � � �$�.� � � �_�-�-� -� ����3� � � � !�e�e���s�� "�u�u���� � � r c �. � | j � |� � | j � |� � D ]"}| j | � |� � �#| j � |� � D ]"}| j | � |� � �#dS )zCRemove a vertex from the graph, disconnecting all edges from/to it.N)r �remover �popr )r r �f�ts r r. zDirectedGraph.remove' s� � � �� � �c�"�"�"�� �#�#�C�(�(� +� +�A� �O�A� � %� %�c� *� *� *� *�� �$�$�S�)�)� *� *�A� �N�1� � $� $�S� )� )� )� )� *� *r c �> � || j | v o|| j | v S r )r r �r r0 r1 s r � connectedzDirectedGraph.connected/ s% � ��D�O�A�&�&�A�1���q�0A�+A�Ar c � � || j vrt |� � �| j | � |� � | j | � |� � dS )zgConnect two existing vertices. Nothing happens if the vertices are already connected. N)r �KeyErrorr r, r r3 s r �connectzDirectedGraph.connect2 sY � � �D�N� "� "��1�+�+� � ��q�� � �a� � � � ���� � �q�!�!�!�!�!r c # �^ K � | j � � � D ]\ }}|D ]}||fV � � �d S r )r r' )r r0 �childrenr1 s r � iter_edgeszDirectedGraph.iter_edges< sT � � � � �>�/�/�1�1� � �K�A�x� � � ����d� � � � � � � r c �6 � t | j | � � S r )r r r s r � iter_childrenzDirectedGraph.iter_childrenA s � ��D�N�3�'�(�(�(r c �6 � t | j | � � S r )r r r s r � iter_parentszDirectedGraph.iter_parentsD s � ��D�O�C�(�)�)�)r N)�__name__� __module__� __qualname__�__doc__r r r r r) r, r. r4 r7 r: r< r> r r r r r s� � � � � � �0�0� � � � $� $� $�#� #� #�%� %� %�� � �%� %� %�*� *� *�B� B� B�"� "� "�� � � )� )� )�*� *� *� *� *r r c �> � e Zd Zd d�Zd� Zd� ZeZd� Zd� Zd� Z d� Z dS ) �IteratorMappingNc �4 � || _ || _ |pi | _ d S r )�_mapping� _accessor�_appends)r �mapping�accessor�appendss r r zIteratorMapping.__init__I s � � �� �!��� � �2�� � � r c �N � d� | j | j | j � � S )Nz!IteratorMapping({!r}, {!r}, {!r}))�formatrF rG rH r s r �__repr__zIteratorMapping.__repr__N s) � �2�9�9� �M� �N� �M� � � r c �8 � t | j p| j � � S r )�boolrF rH r s r �__bool__zIteratorMapping.__bool__U s � ��D�M�2�T�]�3�3�3r c �& � || j v p|| j v S r )rF rH r s r r z IteratorMapping.__contains__Z s � ��d�m�#�;�s�d�m�';�;r c � � | j | }n*# t $ r t | j | � � cY S w xY wt j | � |� � | j � |d� � � � S )Nr )rF r6 r rH � itertools�chainrG �get)r r# r$ s r � __getitem__zIteratorMapping.__getitem__] s{ � � *�� �a� �A�A��� *� *� *��� �a�(�)�)� )� )� )� *������t�~�~�a� 0� 0�$�-�2C�2C�A�r�2J�2J�K�K�Ks � �$7�7c �^ � � � fd�� j D � � }t j � j |� � S )Nc 3 �. �K � | ]}|�j v� |V � �d S r �rF �r" r# r s �r � <genexpr>z+IteratorMapping.__iter__.<locals>.<genexpr>e s/ �� � � �C�C�a�A�T�]�,B�,B��,B�,B�,B�,B�C�Cr )rH rT rU rF �r �mores ` r r zIteratorMapping.__iter__d s2 �� �C�C�C�C�4�=�C�C�C����t�}�d�3�3�3r c �r � � t � fd�� j D � � � � }t � j � � |z S )Nc 3 �. �K � | ]}|�j v� d V � �dS )r NrZ r[ s �r r\ z*IteratorMapping.__len__.<locals>.<genexpr>i s/ �� � � �F�F��q�� �/E�/E�1�/E�/E�/E�/E�F�Fr )�sumrH r rF r] s ` r r zIteratorMapping.__len__h s< �� ��F�F�F�F�d�m�F�F�F�F�F���4�=�!�!�D�(�(r r ) r? r@ rA r rN rQ � __nonzero__r rW r r r r r rD rD H s� � � � � � �&� &� &� &� � � �4� 4� 4� �K�<� <� <�L� L� L�4� 4� 4�)� )� )� )� )r rD c �. � e Zd ZdZd� Zd� Zd� ZeZd� ZdS )�_FactoryIterableViewa: Wrap an iterator factory returned by `find_matches()`. Calling `iter()` on this class would invoke the underlying iterator factory, making it a "collection with ordering" that can be iterated through multiple times, but lacks random access methods presented in built-in Python sequence types. c �" � || _ d | _ d S r )�_factory� _iterable)r �factorys r r z _FactoryIterableView.__init__v s � � �� � ����r c �l � d� t | � � j t | � � � � S �Nz{}({}))rM �typer? �listr s r rN z _FactoryIterableView.__repr__z s% � ����t�D�z�z� 2�D��J�J�?�?�?r c �d � t t | � � � � n# t $ r Y dS w xY wdS )NFT)�nextr � StopIterationr s r rQ z _FactoryIterableView.__bool__} sE � � � ��d��� � � � �� � � � ��5�5� �����ts � � -�-c � � | j �| � � � n| j }t j |� � \ | _ }|S r )rg rf rT �tee)r �iterable�currents r r z _FactoryIterableView.__iter__� s< � � #�~� 5�D�M�M�O�O�O�4�>� � #,�-��"9�"9� �����r N� r? r@ rA rB r rN rQ rb r r r r rd rd m sd � � � � � �� � � � �@� @� @�� � � �K�� � � � r rd c �. � e Zd ZdZd� Zd� Zd� ZeZd� ZdS )�_SequenceIterableViewz�Wrap an iterable returned by find_matches(). This is essentially just a proxy to the underlying sequence that provides the same interface as `_FactoryIterableView`. c � � || _ d S r )� _sequence)r �sequences r r z _SequenceIterableView.__init__� s � �!����r c �\ � d� t | � � j | j � � S rj )rM rk r? rx r s r rN z _SequenceIterableView.__repr__� s! � ����t�D�z�z� 2�D�N�C�C�Cr c �* � t | j � � S r )rP rx r s r rQ z _SequenceIterableView.__bool__� r r c �* � t | j � � S r )r rx r s r r z _SequenceIterableView.__iter__� r r Nrt r r r rv rv � sd � � � � � �� � "� "� "�D� D� D�$� $� $� �K�$� $� $� $� $r rv c � � t | � � rt | � � S t | t j � � st | � � } t | � � S )zCBuild an iterable view from the value returned by `find_matches()`.)�callablerd � isinstancer �Sequencerl rv )�matchess r �build_iter_viewr� � sN � ����� -�#�G�,�,�,� �g�� 7� 8� 8� ��w�-�-�� �� )� )�)r ) rT �compatr �objectr �MappingrD rd rv r� r r r �<module>r� s� �� � � � � #� #� #� #� #� #�?*� ?*� ?*� ?*� ?*�F� ?*� ?*� ?*�D")� ")� ")� ")� ")�o�-� ")� ")� ")�J � � � � �6� � � �B$� $� $� $� $�F� $� $� $�,*� *� *� *� *r compat/__init__.py 0000644 00000000000 15004442445 0010130 0 ustar 00 compat/__pycache__/__init__.cpython-311.pyc 0000644 00000000344 15004442445 0014503 0 ustar 00 � ]�bg � � � d S )N� r � �w/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/compat/__init__.py�<module>r s �� � r compat/__pycache__/collections_abc.cpython-311.pyc 0000644 00000000767 15004442445 0016100 0 ustar 00 � ]�bg� � �H � d dgZ ddlmZmZ dS # e$ r ddlmZmZ Y dS w xY w)�Mapping�Sequence� )r r N)�__all__�collections.abcr r � ImportError� collections� � �~/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py�<module>r sn �� �j� !��.�1�1�1�1�1�1�1�1�1�1��� .� .� .�-�-�-�-�-�-�-�-�-�-�-�.���s � � !�! compat/collections_abc.py 0000644 00000000234 15004442445 0011525 0 ustar 00 __all__ = ["Mapping", "Sequence"] try: from collections.abc import Mapping, Sequence except ImportError: from collections import Mapping, Sequence providers.py 0000644 00000013357 15004442445 0007146 0 ustar 00 class AbstractProvider(object): """Delegate class to provide the required interface for the resolver.""" def identify(self, requirement_or_candidate): """Given a requirement, return an identifier for it. This is used to identify a requirement, e.g. whether two requirements should have their specifier parts merged. """ raise NotImplementedError def get_preference( self, identifier, resolutions, candidates, information, backtrack_causes, ): """Produce a sort key for given requirement based on preference. The preference is defined as "I think this requirement should be resolved first". The lower the return value is, the more preferred this group of arguments is. :param identifier: An identifier as returned by ``identify()``. This identifies the dependency matches which should be returned. :param resolutions: Mapping of candidates currently pinned by the resolver. Each key is an identifier, and the value is a candidate. The candidate may conflict with requirements from ``information``. :param candidates: Mapping of each dependency's possible candidates. Each value is an iterator of candidates. :param information: Mapping of requirement information of each package. Each value is an iterator of *requirement information*. :param backtrack_causes: Sequence of requirement information that were the requirements that caused the resolver to most recently backtrack. A *requirement information* instance is a named tuple with two members: * ``requirement`` specifies a requirement contributing to the current list of candidates. * ``parent`` specifies the candidate that provides (depended on) the requirement, or ``None`` to indicate a root requirement. The preference could depend on various issues, including (not necessarily in this order): * Is this package pinned in the current resolution result? * How relaxed is the requirement? Stricter ones should probably be worked on first? (I don't know, actually.) * How many possibilities are there to satisfy this requirement? Those with few left should likely be worked on first, I guess? * Are there any known conflicts for this requirement? We should probably work on those with the most known conflicts. A sortable value should be returned (this will be used as the ``key`` parameter of the built-in sorting function). The smaller the value is, the more preferred this requirement is (i.e. the sorting function is called with ``reverse=False``). """ raise NotImplementedError def find_matches(self, identifier, requirements, incompatibilities): """Find all possible candidates that satisfy the given constraints. :param identifier: An identifier as returned by ``identify()``. This identifies the dependency matches of which should be returned. :param requirements: A mapping of requirements that all returned candidates must satisfy. Each key is an identifier, and the value an iterator of requirements for that dependency. :param incompatibilities: A mapping of known incompatibilities of each dependency. Each key is an identifier, and the value an iterator of incompatibilities known to the resolver. All incompatibilities *must* be excluded from the return value. This should try to get candidates based on the requirements' types. For VCS, local, and archive requirements, the one-and-only match is returned, and for a "named" requirement, the index(es) should be consulted to find concrete candidates for this requirement. The return value should produce candidates ordered by preference; the most preferred candidate should come first. The return type may be one of the following: * A callable that returns an iterator that yields candidates. * An collection of candidates. * An iterable of candidates. This will be consumed immediately into a list of candidates. """ raise NotImplementedError def is_satisfied_by(self, requirement, candidate): """Whether the given requirement can be satisfied by a candidate. The candidate is guaranteed to have been generated from the requirement. A boolean should be returned to indicate whether ``candidate`` is a viable solution to the requirement. """ raise NotImplementedError def get_dependencies(self, candidate): """Get dependencies of a candidate. This should return a collection of requirements that `candidate` specifies as its dependencies. """ raise NotImplementedError class AbstractResolver(object): """The thing that performs the actual resolution work.""" base_exception = Exception def __init__(self, provider, reporter): self.provider = provider self.reporter = reporter def resolve(self, requirements, **kwargs): """Take a collection of constraints, spit out the resolution result. This returns a representation of the final resolution state, with one guarenteed attribute ``mapping`` that contains resolved candidates as values. The keys are their respective identifiers. :param requirements: A collection of constraints. :param kwargs: Additional keyword arguments that subclasses may accept. :raises: ``self.base_exception`` or its subclass. """ raise NotImplementedError reporters.py 0000644 00000003101 15004442445 0007140 0 ustar 00 class BaseReporter(object): """Delegate class to provider progress reporting for the resolver.""" def starting(self): """Called before the resolution actually starts.""" def starting_round(self, index): """Called before each round of resolution starts. The index is zero-based. """ def ending_round(self, index, state): """Called before each round of resolution ends. This is NOT called if the resolution ends at this round. Use `ending` if you want to report finalization. The index is zero-based. """ def ending(self, state): """Called before the resolution ends successfully.""" def adding_requirement(self, requirement, parent): """Called when adding a new requirement into the resolve criteria. :param requirement: The additional requirement to be applied to filter the available candidaites. :param parent: The candidate that requires ``requirement`` as a dependency, or None if ``requirement`` is one of the root requirements passed in from ``Resolver.resolve()``. """ def resolving_conflicts(self, causes): """Called when starting to attempt requirement conflict resolution. :param causes: The information on the collision that caused the backtracking. """ def rejecting_candidate(self, criterion, candidate): """Called when rejecting a candidate during backtracking.""" def pinning(self, candidate): """Called when adding a candidate to the potential solution.""" resolvers.py 0000644 00000050037 15004442445 0007151 0 ustar 00 import collections import itertools import operator from .providers import AbstractResolver from .structs import DirectedGraph, IteratorMapping, build_iter_view RequirementInformation = collections.namedtuple( "RequirementInformation", ["requirement", "parent"] ) class ResolverException(Exception): """A base class for all exceptions raised by this module. Exceptions derived by this class should all be handled in this module. Any bubbling pass the resolver should be treated as a bug. """ class RequirementsConflicted(ResolverException): def __init__(self, criterion): super(RequirementsConflicted, self).__init__(criterion) self.criterion = criterion def __str__(self): return "Requirements conflict: {}".format( ", ".join(repr(r) for r in self.criterion.iter_requirement()), ) class InconsistentCandidate(ResolverException): def __init__(self, candidate, criterion): super(InconsistentCandidate, self).__init__(candidate, criterion) self.candidate = candidate self.criterion = criterion def __str__(self): return "Provided candidate {!r} does not satisfy {}".format( self.candidate, ", ".join(repr(r) for r in self.criterion.iter_requirement()), ) class Criterion(object): """Representation of possible resolution results of a package. This holds three attributes: * `information` is a collection of `RequirementInformation` pairs. Each pair is a requirement contributing to this criterion, and the candidate that provides the requirement. * `incompatibilities` is a collection of all known not-to-work candidates to exclude from consideration. * `candidates` is a collection containing all possible candidates deducted from the union of contributing requirements and known incompatibilities. It should never be empty, except when the criterion is an attribute of a raised `RequirementsConflicted` (in which case it is always empty). .. note:: This class is intended to be externally immutable. **Do not** mutate any of its attribute containers. """ def __init__(self, candidates, information, incompatibilities): self.candidates = candidates self.information = information self.incompatibilities = incompatibilities def __repr__(self): requirements = ", ".join( "({!r}, via={!r})".format(req, parent) for req, parent in self.information ) return "Criterion({})".format(requirements) def iter_requirement(self): return (i.requirement for i in self.information) def iter_parent(self): return (i.parent for i in self.information) class ResolutionError(ResolverException): pass class ResolutionImpossible(ResolutionError): def __init__(self, causes): super(ResolutionImpossible, self).__init__(causes) # causes is a list of RequirementInformation objects self.causes = causes class ResolutionTooDeep(ResolutionError): def __init__(self, round_count): super(ResolutionTooDeep, self).__init__(round_count) self.round_count = round_count # Resolution state in a round. State = collections.namedtuple("State", "mapping criteria backtrack_causes") class Resolution(object): """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. """ def __init__(self, provider, reporter): self._p = provider self._r = reporter self._states = [] @property def state(self): try: return self._states[-1] except IndexError: raise AttributeError("state") def _push_new_state(self): """Push a new state into history. This new state will be used to hold resolution results of the next coming round. """ base = self._states[-1] state = State( mapping=base.mapping.copy(), criteria=base.criteria.copy(), backtrack_causes=base.backtrack_causes[:], ) self._states.append(state) def _add_to_criteria(self, criteria, requirement, parent): self._r.adding_requirement(requirement=requirement, parent=parent) identifier = self._p.identify(requirement_or_candidate=requirement) criterion = criteria.get(identifier) if criterion: incompatibilities = list(criterion.incompatibilities) else: incompatibilities = [] matches = self._p.find_matches( identifier=identifier, requirements=IteratorMapping( criteria, operator.methodcaller("iter_requirement"), {identifier: [requirement]}, ), incompatibilities=IteratorMapping( criteria, operator.attrgetter("incompatibilities"), {identifier: incompatibilities}, ), ) if criterion: information = list(criterion.information) information.append(RequirementInformation(requirement, parent)) else: information = [RequirementInformation(requirement, parent)] criterion = Criterion( candidates=build_iter_view(matches), information=information, incompatibilities=incompatibilities, ) if not criterion.candidates: raise RequirementsConflicted(criterion) criteria[identifier] = criterion def _remove_information_from_criteria(self, criteria, parents): """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. """ if not parents: return for key, criterion in criteria.items(): criteria[key] = Criterion( criterion.candidates, [ information for information in criterion.information if ( information.parent is None or self._p.identify(information.parent) not in parents ) ], criterion.incompatibilities, ) def _get_preference(self, name): return self._p.get_preference( identifier=name, resolutions=self.state.mapping, candidates=IteratorMapping( self.state.criteria, operator.attrgetter("candidates"), ), information=IteratorMapping( self.state.criteria, operator.attrgetter("information"), ), backtrack_causes=self.state.backtrack_causes, ) def _is_current_pin_satisfying(self, name, criterion): try: current_pin = self.state.mapping[name] except KeyError: return False return all( self._p.is_satisfied_by(requirement=r, candidate=current_pin) for r in criterion.iter_requirement() ) def _get_updated_criteria(self, candidate): criteria = self.state.criteria.copy() for requirement in self._p.get_dependencies(candidate=candidate): self._add_to_criteria(criteria, requirement, parent=candidate) return criteria def _attempt_to_pin_criterion(self, name): criterion = self.state.criteria[name] causes = [] for candidate in criterion.candidates: try: criteria = self._get_updated_criteria(candidate) except RequirementsConflicted as e: self._r.rejecting_candidate(e.criterion, candidate) causes.append(e.criterion) continue # Check the newly-pinned candidate actually works. This should # always pass under normal circumstances, but in the case of a # faulty provider, we will raise an error to notify the implementer # to fix find_matches() and/or is_satisfied_by(). satisfied = all( self._p.is_satisfied_by(requirement=r, candidate=candidate) for r in criterion.iter_requirement() ) if not satisfied: raise InconsistentCandidate(candidate, criterion) self._r.pinning(candidate=candidate) self.state.criteria.update(criteria) # Put newly-pinned candidate at the end. This is essential because # backtracking looks at this mapping to get the last pin. self.state.mapping.pop(name, None) self.state.mapping[name] = candidate return [] # All candidates tried, nothing works. This criterion is a dead # end, signal for backtracking. return causes def _backjump(self, causes): """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. """ incompatible_reqs = itertools.chain( (c.parent for c in causes if c.parent is not None), (c.requirement for c in causes), ) incompatible_deps = {self._p.identify(r) for r in incompatible_reqs} while len(self._states) >= 3: # Remove the state that triggered backtracking. del self._states[-1] # Ensure to backtrack to a state that caused the incompatibility incompatible_state = False while not incompatible_state: # Retrieve the last candidate pin and known incompatibilities. try: broken_state = self._states.pop() name, candidate = broken_state.mapping.popitem() except (IndexError, KeyError): raise ResolutionImpossible(causes) current_dependencies = { self._p.identify(d) for d in self._p.get_dependencies(candidate) } incompatible_state = not current_dependencies.isdisjoint( incompatible_deps ) incompatibilities_from_broken = [ (k, list(v.incompatibilities)) for k, v in broken_state.criteria.items() ] # Also mark the newly known incompatibility. incompatibilities_from_broken.append((name, [candidate])) # Create a new state from the last known-to-work one, and apply # the previously gathered incompatibility information. def _patch_criteria(): for k, incompatibilities in incompatibilities_from_broken: if not incompatibilities: continue try: criterion = self.state.criteria[k] except KeyError: continue matches = self._p.find_matches( identifier=k, requirements=IteratorMapping( self.state.criteria, operator.methodcaller("iter_requirement"), ), incompatibilities=IteratorMapping( self.state.criteria, operator.attrgetter("incompatibilities"), {k: incompatibilities}, ), ) candidates = build_iter_view(matches) if not candidates: return False incompatibilities.extend(criterion.incompatibilities) self.state.criteria[k] = Criterion( candidates=candidates, information=list(criterion.information), incompatibilities=incompatibilities, ) return True self._push_new_state() success = _patch_criteria() # It works! Let's work on this new state. if success: return True # State does not work after applying known incompatibilities. # Try the still previous state. # No way to backtrack anymore. return False def resolve(self, requirements, max_rounds): if self._states: raise RuntimeError("already resolved") self._r.starting() # Initialize the root state. self._states = [ State( mapping=collections.OrderedDict(), criteria={}, backtrack_causes=[], ) ] for r in requirements: try: self._add_to_criteria(self.state.criteria, r, parent=None) except RequirementsConflicted as e: raise ResolutionImpossible(e.criterion.information) # The root state is saved as a sentinel so the first ever pin can have # something to backtrack to if it fails. The root state is basically # pinning the virtual "root" package in the graph. self._push_new_state() for round_index in range(max_rounds): self._r.starting_round(index=round_index) unsatisfied_names = [ key for key, criterion in self.state.criteria.items() if not self._is_current_pin_satisfying(key, criterion) ] # All criteria are accounted for. Nothing more to pin, we are done! if not unsatisfied_names: self._r.ending(state=self.state) return self.state # keep track of satisfied names to calculate diff after pinning satisfied_names = set(self.state.criteria.keys()) - set( unsatisfied_names ) # Choose the most preferred unpinned criterion to try. name = min(unsatisfied_names, key=self._get_preference) failure_causes = self._attempt_to_pin_criterion(name) if failure_causes: causes = [i for c in failure_causes for i in c.information] # Backjump if pinning fails. The backjump process puts us in # an unpinned state, so we can work on it in the next round. self._r.resolving_conflicts(causes=causes) success = self._backjump(causes) self.state.backtrack_causes[:] = causes # Dead ends everywhere. Give up. if not success: raise ResolutionImpossible(self.state.backtrack_causes) else: # discard as information sources any invalidated names # (unsatisfied names that were previously satisfied) newly_unsatisfied_names = { key for key, criterion in self.state.criteria.items() if key in satisfied_names and not self._is_current_pin_satisfying(key, criterion) } self._remove_information_from_criteria( self.state.criteria, newly_unsatisfied_names ) # Pinning was successful. Push a new state to do another pin. self._push_new_state() self._r.ending_round(index=round_index, state=self.state) raise ResolutionTooDeep(max_rounds) def _has_route_to_root(criteria, key, all_keys, connected): if key in connected: return True if key not in criteria: return False for p in criteria[key].iter_parent(): try: pkey = all_keys[id(p)] except KeyError: continue if pkey in connected: connected.add(key) return True if _has_route_to_root(criteria, pkey, all_keys, connected): connected.add(key) return True return False Result = collections.namedtuple("Result", "mapping graph criteria") def _build_result(state): mapping = state.mapping all_keys = {id(v): k for k, v in mapping.items()} all_keys[id(None)] = None graph = DirectedGraph() graph.add(None) # Sentinel as root dependencies' parent. connected = {None} for key, criterion in state.criteria.items(): if not _has_route_to_root(state.criteria, key, all_keys, connected): continue if key not in graph: graph.add(key) for p in criterion.iter_parent(): try: pkey = all_keys[id(p)] except KeyError: continue if pkey not in graph: graph.add(pkey) graph.connect(pkey, key) return Result( mapping={k: v for k, v in mapping.items() if k in connected}, graph=graph, criteria=state.criteria, ) class Resolver(AbstractResolver): """The thing that performs the actual resolution work.""" base_exception = ResolverException def resolve(self, requirements, max_rounds=100): """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. """ resolution = Resolution(self.provider, self.reporter) state = resolution.resolve(requirements, max_rounds=max_rounds) return _build_result(state) structs.py 0000644 00000011543 15004442445 0006633 0 ustar 00 import itertools from .compat import collections_abc class DirectedGraph(object): """A graph structure with directed edges.""" def __init__(self): self._vertices = set() self._forwards = {} # <key> -> Set[<key>] self._backwards = {} # <key> -> Set[<key>] def __iter__(self): return iter(self._vertices) def __len__(self): return len(self._vertices) def __contains__(self, key): return key in self._vertices def copy(self): """Return a shallow copy of this graph.""" other = DirectedGraph() other._vertices = set(self._vertices) other._forwards = {k: set(v) for k, v in self._forwards.items()} other._backwards = {k: set(v) for k, v in self._backwards.items()} return other def add(self, key): """Add a new vertex to the graph.""" if key in self._vertices: raise ValueError("vertex exists") self._vertices.add(key) self._forwards[key] = set() self._backwards[key] = set() def remove(self, key): """Remove a vertex from the graph, disconnecting all edges from/to it.""" self._vertices.remove(key) for f in self._forwards.pop(key): self._backwards[f].remove(key) for t in self._backwards.pop(key): self._forwards[t].remove(key) def connected(self, f, t): return f in self._backwards[t] and t in self._forwards[f] def connect(self, f, t): """Connect two existing vertices. Nothing happens if the vertices are already connected. """ if t not in self._vertices: raise KeyError(t) self._forwards[f].add(t) self._backwards[t].add(f) def iter_edges(self): for f, children in self._forwards.items(): for t in children: yield f, t def iter_children(self, key): return iter(self._forwards[key]) def iter_parents(self, key): return iter(self._backwards[key]) class IteratorMapping(collections_abc.Mapping): def __init__(self, mapping, accessor, appends=None): self._mapping = mapping self._accessor = accessor self._appends = appends or {} def __repr__(self): return "IteratorMapping({!r}, {!r}, {!r})".format( self._mapping, self._accessor, self._appends, ) def __bool__(self): return bool(self._mapping or self._appends) __nonzero__ = __bool__ # XXX: Python 2. def __contains__(self, key): return key in self._mapping or key in self._appends def __getitem__(self, k): try: v = self._mapping[k] except KeyError: return iter(self._appends[k]) return itertools.chain(self._accessor(v), self._appends.get(k, ())) def __iter__(self): more = (k for k in self._appends if k not in self._mapping) return itertools.chain(self._mapping, more) def __len__(self): more = sum(1 for k in self._appends if k not in self._mapping) return len(self._mapping) + more class _FactoryIterableView(object): """Wrap an iterator factory returned by `find_matches()`. Calling `iter()` on this class would invoke the underlying iterator factory, making it a "collection with ordering" that can be iterated through multiple times, but lacks random access methods presented in built-in Python sequence types. """ def __init__(self, factory): self._factory = factory self._iterable = None def __repr__(self): return "{}({})".format(type(self).__name__, list(self)) def __bool__(self): try: next(iter(self)) except StopIteration: return False return True __nonzero__ = __bool__ # XXX: Python 2. def __iter__(self): iterable = ( self._factory() if self._iterable is None else self._iterable ) self._iterable, current = itertools.tee(iterable) return current class _SequenceIterableView(object): """Wrap an iterable returned by find_matches(). This is essentially just a proxy to the underlying sequence that provides the same interface as `_FactoryIterableView`. """ def __init__(self, sequence): self._sequence = sequence def __repr__(self): return "{}({})".format(type(self).__name__, self._sequence) def __bool__(self): return bool(self._sequence) __nonzero__ = __bool__ # XXX: Python 2. def __iter__(self): return iter(self._sequence) def build_iter_view(matches): """Build an iterable view from the value returned by `find_matches()`.""" if callable(matches): return _FactoryIterableView(matches) if not isinstance(matches, collections_abc.Sequence): matches = list(matches) return _SequenceIterableView(matches) py.typed 0000644 00000000000 15004442445 0006233 0 ustar 00
| ver. 1.4 |
Github
|
.
| PHP 8.1.31 | Генерация страницы: 0 |
proxy
|
phpinfo
|
Настройка