📁 File Manager Pro
v10.0.3 | PHP: 8.2.31
Server: LiteSpeed
2026-06-28 12:54:10
📂
/ (Root)
/
opt
/
hc_python
/
lib
/
python3.12
/
site-packages
/
pip
/
_internal
/
resolution
/
resolvelib
/
__pycache__
📍 /opt/hc_python/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__
🔄 Refresh
✏️
Editing: provider.cpython-312.pyc
Read Only
� i�*jv/ � �: � d dl mZ d dlZd dlmZ d dlmZmZmZm Z d dl m Z d dl m Z mZ d dlmZ d dlmZ d d lmZmZmZ d d lmZ d d lmZ d d lm Z e r d dlm Z d dl m Z e eef Z eeee!f Z"neZ"dZ# ed� Z$ ed� Z% dd�Z& G d� de"� Z'y)� )� annotationsN)� defaultdict)�Iterable�Iterator�Mapping�Sequence)�cache)� TYPE_CHECKING�TypeVar)�AbstractProvider)�InstallRequirement� )� Candidate� Constraint� Requirement)�REQUIRES_PYTHON_IDENTIFIER)�Factory)�ExplicitRequirement)� Preference)�RequirementInformation� �D�Vc �X � || v r| | S |j d� \ }}}|r || v r| | S |S )ai Get item from a package name lookup mapping with a resolver identifier. This extra logic is needed when the target mapping is keyed by package name, which cannot be directly looked up with an identifier (which may contain requested extras). Additional logic is added to also look up a value by "cleaning up" the extras from the identifier. �[)� partition)�mapping� identifier�default�name� open_bracket�_s �[/opt/hc_python/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/provider.py�_get_with_identifierr$ 8 sH � � �W� ��z�"�"� '� 0� 0�� 5��D�,�������t�}� � �N� c �� � e Zd ZdZ d d�Zed d�� Zd d�Z dd�Z dd�Z dd�Z e e dd�� � Z dd �Zy )� PipProvidera� Pip's provider implementation for resolvelib. :params constraints: A mapping of constraints specified by the user. Keys are canonicalized project names. :params ignore_dependencies: Whether the user specified ``--no-deps``. :params upgrade_strategy: The user-specified upgrade strategy. :params user_requested: A set of canonicalized package names that the user supplied for pip to install/upgrade. c � � || _ || _ || _ || _ || _ t t � | _ t � | _ y �N) �_factory� _constraints�_ignore_dependencies�_upgrade_strategy�_user_requestedr �int�_conflict_counts�set�_conflict_promoted)�self�factory� constraints�ignore_dependencies�upgrade_strategy�user_requesteds r# �__init__zPipProvider.__init__\ sB � � �� � '���$7��!�!1�� � -�� �7B�3�7G�� �,/�E�� r% c � � | j S )z�Public view of user-specified constraints. Exposes the provider's constraints mapping without encouraging external callers to reach into private attributes. )r+ )r3 s r# r5 zPipProvider.constraintsl s � � � � � r% c � � |j S r) )r )r3 �requirement_or_candidates r# �identifyzPipProvider.identifyu s � �'�,�,�,r% c �2 � t � }|D ]� }|j j g}|j �%|j |j j � |D ]a } |j | � | |vs�| j | xx dz cc< | j | t k\ s�G| j j | � �c �� g } g } |D ]F } | t k( r| gc S | |v r| j | � �'| | j v s�6| j | � �H | r| S | r| S |S )af Produce a subset of identifiers that should be considered before others. Currently pip narrows the following selection: * Requires-Python, if present is always returned by itself * Backtrack causes are considered next because they can be identified in linear time here, whereas because get_preference() is called for each identifier, it would be quadratic to check for them there. Further, the current backtrack causes likely need to be resolved before other requirements as a resolution can't be found while there is a conflict. * Identifiers that repeatedly appear as not-yet-pinned in conflicts get promoted so they are resolved earlier. This lets their constraints take effect before other packages pick a version. r ) r1 � requirementr �parent�append�addr0 � _CONFLICT_PRIORITY_THRESHOLDr2 r ) r3 � identifiers� resolutions� candidates� information�backtrack_causes�backtrack_identifiers�info�namesr �current_backtrack_causes�promotedr s r# � narrow_requirement_selectionz(PipProvider.narrow_requirement_selectionx s � �, !$�� �$�D��%�%�*�*�+�E��{�{�&�� � �T�[�[� -� -�.� ��%�)�)�$�/��{�*��)�)�$�/�1�4�/��,�,�T�2�6R�R� �/�/�3�3�D�9� � %� $&� ���%�J�� 7�7�"�|�#�� 2�2�(�/�/� �;���T� 4� 4�4���� �+�� &� $�+� +� ��O��r% c � � t t || � � d}|sd}d}n t d� || D � � \ } }t | � }d� |D � D � � cg c]! } | D ] } | j | j f�� �# } } } t d� | D � � } t d� | D � � }t | � }| j j |t j � }|| j v }| | | | || |fS # t $ r d}Y ��w xY wc c} } w )a~ Produce a sort key for given requirement based on preference. The lower the return value is, the more preferred this group of arguments is. Currently pip considers the following in order: * Any requirement that is "direct", e.g., points to an explicit URL. * Any requirement that is "pinned", i.e., contains the operator ``===`` or ``==`` without a wildcard. * Any requirement that imposes an upper version limit, i.e., contains the operator ``<``, ``<=``, ``~=``, or ``==`` with a wildcard. Because pip prioritizes the latest version, preferring explicit upper bounds can rule out infeasible candidates sooner. This does not imply that upper bounds are good practice; they can make dependency management and resolution harder. * Order user-specified requirements as they are specified, placing other requirements afterward. * Any "non-free" requirement, i.e., one that contains at least one operator, such as ``>=`` or ``!=``. * Alphabetical order for consistency (aids debuggability). TF� c 3 �h K � | ]* \ }}t |t � |j � d f�� �, y�w)r N)� isinstancer �get_candidate_lookup)�.0�rr" s r# � <genexpr>z-PipProvider.get_preference.<locals>.<genexpr>� s8 � �� � � 7���1� ��#6�7��9O�9O�9Q�RS�9T�U� 7�s �02c 3 �: K � | ] }|s�|j �� � y �wr) )� specifier)rT �ireqs r# rV z-PipProvider.get_preference.<locals>.<genexpr>� s � �� �!K�U�T�d�$�.�.�U�s ��c 3 �> K � | ] \ }}|d d dk( xr d|v�� � y �w)N� �==�*rP �rT �op�vers r# rV z-PipProvider.get_preference.<locals>.<genexpr>� s+ � �� �V�I���S�r�"�1�v��~�;�C�s�N�;�I�s � c 3 �D K � | ] \ }}|d v xs |dk( xr d|v �� � y�w))�<z<=z~=r\ r] NrP r^ s r# rV z-PipProvider.get_preference.<locals>.<genexpr>� s7 � �� � �$���C� �%�%� E�2��:�+D�#��*� E�$�s � ) �next�iter� StopIteration�zip�any�operator�version�boolr. �get�math�infr2 )r3 r rE rF rG rH �has_information�direct�ireqs�directs� specifier_setrX � operators�pinned� upper_bounded�unfree�requested_order�conflict_promoteds r# �get_preferencezPipProvider.get_preference� sK � �< #� ��k�*�-�.� /� #�O� ��F�;=�E� !�� +�J� 7�� �N�G�U� ��\�F� "L�U�!K�, �!K� � *� � � � ��!2�!2� 3� *� 4�!K� � , � �V�I�V�V��� �$� � � � �i� �� �.�.�2�2�:�t�x�x�H�� &�$�*A�*A� A�� "� !��J��J� � � ��J� � � ��M � $� $�O� $��,, s �C, �&C=�, C:�9C:c �� � � d� fd� }t � j |t j � �� }� j j ||| ||� |� j �� S )Nc �| �� �j dk( ry�j dk( r t �j | d�� }|duS y)a� Are upgrades allowed for this project? This checks the upgrade strategy, and whether the project was one that the user specified in the command line, in order to decide whether we should upgrade if there's a newer version available. (Note that we don't need access to the `--upgrade` flag, because an upgrade strategy of "to-satisfy-only" means that `--upgrade` was not specified). �eagerTzonly-if-neededN�r F)r- r$ r. )r � user_orderr3 s �r# �_eligible_for_upgradez7PipProvider.find_matches.<locals>._eligible_for_upgrade sN �� � �%�%��0���'�'�+;�;� 1��(�(� � � � � "��-�-�r% r} )r � requirements� constraint�prefers_installed�incompatibilities�is_satisfied_by)r �str�returnrj )r$ r+ r �emptyr* �find_candidatesr� )r3 r r� r� r r� s ` r# � find_matcheszPipProvider.find_matches sj �� � �, *� � � � � �$�$�&� � � �}�}�,�,�!�%�!�#8��#D� D� /� � 0� 0� -� � r% c �$ � | j |� S r) )r� )r? � candidates r# r� zPipProvider.is_satisfied_by* s � � �*�*�9�5�5r% c �L � | j }d� |j |� D � S )Nc 3 �& K � | ] }|��|�� � y �wr) rP )rT rU s r# rV z/PipProvider.get_dependencies.<locals>.<genexpr>2 s � �� �W�E�a�� ��E�s ��)r, �iter_dependencies)r3 r� � with_requiress r# �get_dependenciesz PipProvider.get_dependencies/ s& � � � 5� 5�5� �W�9�6�6�}�E�W�Wr% N) r4 r r5 �dict[str, Constraint]r6 rj r7 r� r8 zdict[str, int]r� �None)r� r� )r< zRequirement | Candidater� r� ) rD � Iterable[str]rE �Mapping[str, Candidate]rF �!Mapping[str, Iterator[Candidate]]rG z-Mapping[str, Iterator[PreferenceInformation]]rH � Sequence[PreferenceInformation]r� r� ) r r� rE r� rF r� rG z-Mapping[str, Iterable[PreferenceInformation]]rH r� r� r )r r� r� z#Mapping[str, Iterator[Requirement]]r� r� r� zIterable[Candidate])r? r r� r r� rj )r� r r� zIterable[Requirement])�__name__� __module__� __qualname__�__doc__r9 �propertyr5 r= rN ry r� � staticmethodr r� r� rP r% r# r' r' Q s6 � ��2��2� +�2� "� 2� � 2� '� 2� �2� �!� �!�-�6�"�6� -�6� 6� 6� C� 6� :� 6� �6�pN ��N � -�N � 6� N � C� N � :� N � �N �`( ��( � :�( � =� ( � � ( �T � �6� � �6�Xr% r' )r zMapping[str, V]r r� r r r� zD | V)(� __future__r rl � collectionsr �collections.abcr r r r � functoolsr �typingr r � pip._vendor.resolvelib.providersr � pip._internal.req.req_installr �baser r r rF r r4 r r� r r � pip._vendor.resolvelib.resolversr �PreferenceInformationr� � _ProviderBaserC r r r$ r' rP r% r# �<module>r� s� �� "� � #� A� A� �� >� <� 4� 4� 2� � -��;�G� 2�;� �3I� J��$�[�)�S�%@�A�M�$�M� � �* �C�L�� �C�L��� ���� �� � �2aX�-� aXr%
💾 Save Changes
❌ Cancel