Файловый менеджер - Редактировать - /home/skymarketplace/public_html/uploads/packaging.tar
Назад
__init__.py 0000644 00000000760 15004414131 0006651 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. __title__ = "packaging" __summary__ = "Core utilities for Python packages" __uri__ = "https://github.com/pypa/packaging" __version__ = "24.1" __author__ = "Donald Stufft and individual contributors" __email__ = "donald@stufft.io" __license__ = "BSD-2-Clause or Apache-2.0" __copyright__ = "2014 %s" % __author__ __pycache__/__init__.cpython-311.pyc 0000644 00000001103 15004414131 0013201 0 ustar 00 � ]�bg� � �, � d Z dZdZdZdZdZdZdez ZdS ) � packagingz"Core utilities for Python packagesz!https://github.com/pypa/packagingz24.1z)Donald Stufft and individual contributorszdonald@stufft.iozBSD-2-Clause or Apache-2.0z2014 %sN)� __title__� __summary__�__uri__� __version__� __author__� __email__� __license__� __copyright__� � �o/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/__init__.py�<module>r s8 �� � �2� � -��� � 8� � � �*� ��J�&� � � r __pycache__/_manylinux.cpython-311.pyc 0000644 00000025274 15004414131 0013644 0 ustar 00 � ]�bgr% � �h � U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl m Z m Z m Z m Z ddlmZmZmZmZ dZdZdZej d+d �� � Zd,d�Zd,d�Zd-d�Z ej d� � � Z de d< G d� de � � Z d.d�Z d.d �Z d.d �Z!d/d �Z"ej# d0d!�� � Z$d1d$�Z%d%d&d'd(�Z&d2d*�Z'dS )3� )� annotationsN)� Generator�Iterator� NamedTuple�Sequence� )�EIClass�EIData�ELFFile�EMachinel ~ i i �path�str�return�%Generator[ELFFile | None, None, None]c # �� K � t | d� � 5 }t |� � V � d d d � � d S # 1 swxY w Y d S # t t t f$ r d V � Y d S w xY w)N�rb)�openr �OSError� TypeError� ValueError)r �fs �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/_manylinux.py� _parse_elfr s� � � � �� �$�� � � ���!�*�*� � � � � � � � � � � � � � � ���� � � � � � �� �Y� � +� � � �� � � � � � ����s, �A �3� A �7�A �7�A � A � A � executable�boolc �< � t | � � 5 }|d uon|j t j k oY|j t j k oD|j t j k o/|j t z t k o|j t z t k cd d d � � S # 1 swxY w Y d S �N)r �capacityr �C32�encodingr �Lsb�machiner �Arm�flags�EF_ARM_ABIMASK�EF_ARM_ABI_VER5�EF_ARM_ABI_FLOAT_HARD�r r s r �_is_linux_armhfr) s� � � �J� � � �1� �T�M� I�� �g�k�)� I�� �f�j�(� I� � �X�\�)� I� ��.�(�O�;� I� ��/�/�3H�H� � � � � � � � � � � � � ���� � � � � � s �A4B�B�Bc �� � t | � � 5 }|d uo>|j t j k o)|j t j k o|j t j k cd d d � � S # 1 swxY w Y d S r ) r r r r r r r! r" r �I386r( s r �_is_linux_i686r, - s� � � �J� � � �1� �T�M� +�� �g�k�)� +�� �f�j�(� +� � �X�]�*� � � � � � � � � � � � � ���� � � � � � s �AA!�!A%�(A%�archs� Sequence[str]c � �� d|v rt | � � S d|v rt | � � S h d��t �fd�|D � � � � S )N�armv7l�i686> �ppc64�s390x�x86_64�aarch64�ppc64le�riscv64� loongarch64c 3 � �K � | ]}|�v V � � d S r � )�.0�arch� allowed_archss �r � <genexpr>z'_have_compatible_abi.<locals>.<genexpr>E s( �� � � �7�7��t�}�$�7�7�7�7�7�7� )r) r, �any)r r- r= s @r �_have_compatible_abirA 7 si �� ��5��� �z�*�*�*� ���� �j�)�)�)�� � �M� �7�7�7�7��7�7�7� 7� 7�7r? c � � dS )N�2 r: r: r? r �<lambda>rD M s � �B� r? zdict[int, int]�_LAST_GLIBC_MINORc �$ � e Zd ZU ded< ded< dS )� _GLibCVersion�int�major�minorN)�__name__� __module__� __qualname__�__annotations__r: r? r rG rG P s" � � � � � � ��J�J�J��J�J�J�J�Jr? rG � str | Nonec � � t j d� � } | �J �| � � � \ }}n$# t t t t f$ r Y dS w xY w|S )zJ Primary implementation of glibc_version_string using os.confstr. �CS_GNU_LIBC_VERSIONN)�os�confstr�rsplit�AssertionError�AttributeErrorr r )�version_string�_�versions r � _glibc_version_string_confstrrZ U sl � ��%'�Z�0E�%F�%F�� �)�)�)�#�*�*�,�,� ��7�7�� �N�G�Z� @� � � ��t�t����� �Ns �/2 � A�Ac �8 � ddl } n# t $ r Y dS w xY w | � d� � }n# t $ r Y dS w xY w |j }n# t $ r Y dS w xY w| j |_ |� � }t |t � � s|� d� � }|S )zG Fallback implementation of glibc_version_string using ctypes. r N�ascii) �ctypes� ImportError�CDLLr �gnu_get_libc_versionrV �c_char_p�restype� isinstancer �decode)r] �process_namespacer` � version_strs r � _glibc_version_string_ctypesrg h s� � ��� � � � �� � � � ��t�t����� � "�K�K�� -� -���� � � � ��t�t������ 0� E� � �� � � � � �t�t����� $*�?�� �+�+�-�-�K� �k�3� '� '� 2�!�(�(��1�1� � �s* � � ��/ � =�=�A � A�Ac �: � t � � p t � � S )z9Returns glibc version string, or None if not using glibc.)rZ rg r: r? r �_glibc_version_stringri � s � � (� *� *� L�.J�.L�.L�Lr? rf �tuple[int, int]c � � t j d| � � }|s t j d| � �t � � dS t |� d� � � � t |� d� � � � fS )a3 Parse glibc version. We use a regexp instead of str.split because we want to discard any random junk that might come after the minor version -- this might happen in patched/forked versions of glibc (e.g. Linaro's version of glibc uses version strings like "2.20-2014.11"). See gh-3588. z$(?P<major>[0-9]+)\.(?P<minor>[0-9]+)z;Expected glibc version with 2 components major.minor, got: ����rm rI rJ )�re�match�warnings�warn�RuntimeWarningrH �group)rf �ms r �_parse_glibc_versionru � s� � � ��8�+�F�F�A� � �� � #� � #� #� � � � � �v� �q�w�w�w� � � � �#�a�g�g�g�&6�&6�"7�"7� 7�7r? c �D � t � � } | �dS t | � � S )Nrl )ri ru )rf s r �_get_glibc_versionrw � s& � �'�)�)�K����x� � � ,� ,�,r? r< rY c �< � t � � }||k rdS dd l}n# t $ r Y dS w xY wt |d� � r6|� |d |d | � � }|�t |� � S dS |t dd� � k r$t |d� � rt |j � � S |t dd � � k r$t |d � � rt |j � � S |t dd � � k r$t |d � � rt |j � � S dS ) NFr T�manylinux_compatibler � � �manylinux1_compatible� �manylinux2010_compatible� �manylinux2014_compatible) rw � _manylinuxr^ �hasattrry r rG r| r~ r� )r< rY � sys_glibcr� �results r �_is_compatibler� � sL � �"�$�$�I��7����u�������� � � � ��t�t������z�1�2�2� ��0�0����W�Q�Z��N�N�� � ���<�<� ��t��-��1�%�%�%�%� �:� 6� 7� 7� :�� �8�9�9� 9��-��2�&�&�&�&� �:� 9� :� :� =�� �;�<�<� <��-��2�&�&�&�&� �:� 9� :� :� =�� �;�<�<� <� �4s � � +�+� manylinux2014� manylinux2010� manylinux1))rz r )rz r} )rz r{ � Iterator[str]c # � K � t t j | � � sdS t dd� � }t | � � ddhz rt dd� � }t t � � � }|g}t |j dz dd� � D ]2}t | }|� t ||� � � � �3| D ]�}|D ]�}|j |j k r|j }nd}t |j |d� � D ]i}t |j |� � } d j | � } t || � � r | � d |� �V � | t v r&t | } t || � � r | � d |� �V � �j����dS ) a� Generate manylinux tags compatible to the current platform. :param archs: Sequence of compatible architectures. The first one shall be the closest to the actual architecture and be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be manylinux-compatible. :returns: An iterator of compatible manylinux tags. Nrz � r4 r1 � r rm zmanylinux_{}_{}rX )rA �sysr rG �setrw �rangerI rE �appendrJ �formatr� �_LEGACY_MANYLINUX_MAP) r- �too_old_glibc2� current_glibc�glibc_max_list� glibc_major� glibc_minorr< � glibc_max� min_minor� glibc_version�tag� legacy_tags r � platform_tagsr� � s� � � � � ���� 6� 6� ���"�1�b�)�)�N� �5�z�z�X�v�&�&� -�&�q�!�,�,��!�#5�#7�#7�8�M�#�_�N� �]� 0�1� 4�a��<�<� G� G� �'� �4� �� � �m�K�� E� E�F�F�F�F�� 5� 5��'� 5� 5�I���.�"6�6�6� *� 0� � � � � $�Y�_�i�� D� D� 5� 5� � -�i�o�{� K� K� �.�'�.� �>��!�$� �6�6� *� �/�/�4�/�/�)�)�)� �$9�9�9�!6�}�!E�J�%�d�M�:�:� 5�!+� 4� 4�d� 4� 4�4�4�4�� 5� 5�5� 5r? )r r r r )r r r r )r r r- r. r r )r rO )rf r r rj )r rj )r< r rY rG r r )r- r. r r� )(� __future__r � collections� contextlib� functoolsrR rn r� rp �typingr r r r �_elffiler r r r r% r& r' �contextmanagerr r) r, rA � defaultdictrE rN rG rZ rg ri ru � lru_cacherw r� r� r� r: r? r �<module>r� s* �� "� "� "� "� "� "� "� � � � � � � � � � � � � � � � � � � � � � � � � ���� <� <� <� <� <� <� <� <� <� <� <� <� 8� 8� 8� 8� 8� 8� 8� 8� 8� 8� 8� 8��� ��"� � ��� � � ��� � � � � � � � �8� 8� 8� 8�, %<�K�$;�J�J�$G�$G� � G� G� G� G�� � � � �J� � � � � � � �&)� )� )� )�XM� M� M� M� 8� 8� 8� 8�& ��-� -� -� ��-�� � � �8 � � � � � �-5� -5� -5� -5� -5� -5r? __pycache__/_musllinux.cpython-311.pyc 0000644 00000012323 15004414131 0013647 0 ustar 00 � ]�bg� � � � d Z ddlmZ ddlZddlZddlZddlZddlmZm Z m Z ddl m Z G d� de � � Z d!d �Zej d"d�� � Zd#d�Zedk r�ddlZ ej � � Ze� d� � s J d� � � ede� � ed eej � � � � edd�� � e ej d d e� d d� � d � � � � D ]Z eed �� � �dS dS )$z�PEP 656 support. This module implements logic to detect if the currently running Python is linked against musl, and what musl version is used. � )� annotationsN)�Iterator� NamedTuple�Sequence� )�ELFFilec �$ � e Zd ZU ded< ded< dS )� _MuslVersion�int�major�minorN)�__name__� __module__� __qualname__�__annotations__� � �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/_musllinux.pyr r s" � � � � � � ��J�J�J��J�J�J�J�Jr r �output�str�return�_MuslVersion | Nonec � � d� d� | � � � D � � D � � }t |� � dk s|d d d� dk rd S t j d|d � � }|sd S t t |� d� � � � t |� d� � � � � � � S ) Nc � � g | ]}|�|��S r r ��.0�ns r � <listcomp>z'_parse_musl_version.<locals>.<listcomp> s � � F� F� F�1�A� F�Q� F� F� Fr c 3 �> K � | ]}|� � � V � �d S )N)�stripr s r � <genexpr>z&_parse_musl_version.<locals>.<genexpr> s* � � � �@�@�q������@�@�@�@�@�@r � r � �muslzVersion (\d+)\.(\d+)r )r r )� splitlines�len�re�matchr r �group)r �lines�ms r �_parse_musl_versionr, s� � � F� F�@�@�F�,=�,=�,?�,?�@�@�@� F� F� F�E� �5�z�z�A�~�~��q��"�1�"� ��/�/��t� ��(�%��(�3�3�A� � ��t� �c�!�'�'�!�*�*�o�o�S�������_�_� E� E� E�Er � executablec �6 � t | d� � 5 }t |� � j }ddd� � n # 1 swxY w Y n # t t t f$ r Y dS w xY w|�d|vrdS t j |gt j d�� � }t |j � � S )a` Detect currently-running musl runtime version. This is done by checking the specified executable's dynamic linking information, and invoking the loader to parse its output for a version string. If the loader is musl, the output would be something like:: musl libc (x86_64) Version 1.2.2 Dynamic Program Loader �rbNr$ T)�stderr�text) �openr � interpreter�OSError� TypeError� ValueError� subprocess�run�PIPEr, r0 )r- �f�ld�procs r �_get_musl_versionr= ! s� � �� �*�d� #� #� (�q�����'�B� (� (� (� (� (� (� (� (� (� (� (���� (� (� (� (��� �Y� � +� � � ��t�t����� �z�V�2�%�%��t� �>�2�$�z��T� B� B� B�D� �t�{� +� +�+s' �? �3� ? �7�? �7�? �A�A�archs� Sequence[str]� Iterator[str]c # � K � t t j � � }|�dS | D ]-}t |j dd� � D ]}d|j � d|� d|� �V � ��.dS )a� Generate musllinux tags compatible to the current platform. :param archs: Sequence of compatible architectures. The first one shall be the closest to the actual architecture and be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be musllinux-compatible. :returns: An iterator of compatible musllinux tags. N���� musllinux_�_)r= �sysr- �ranger r )r> �sys_musl�archr s r � platform_tagsrI 8 s� � � � � !�� �0�0�H������ ?� ?���8�>�2�r�2�2� ?� ?�E�>�x�~�>�>��>�>��>�>� >� >� >� >� ?�?� ?r �__main__zlinux-z not linuxzplat:zmusl:ztags:� )�endz[.-]rD �-rB z )r r r r )r- r r r )r> r? r r@ ) �__doc__� __future__r � functoolsr' r7 rE �typingr r r �_elffiler r r, � lru_cacher= rI r � sysconfig� get_platform�plat� startswith�printr- �sub�split�tr r r �<module>r\ s� ��� � #� "� "� "� "� "� � � � � � � � � � � � � � � � � 1� 1� 1� 1� 1� 1� 1� 1� 1� 1� � � � � � �� � � � �:� � � � F� F� F� F� ��,� ,� ,� ��,�,?� ?� ?� ?�& �z������� !�9� !� #� #�D� �?�?�8� $� $�1�1�k�1�1� $� �E�'�4���� �E�'�$�$�S�^�4�4�5�5�5� �E�'�s����� �]�6�2�6�'�3�� � �3��0B�0B�2�0F�G�G� H� H� !� !�� ��a�Z� � � � � � ��!� !r __pycache__/_structures.cpython-311.pyc 0000644 00000007170 15004414131 0014036 0 ustar 00 � ]�bg� � �b � G d � d� � Z e � � Z G d� d� � Z e� � ZdS )c � � e Zd Zdefd�Zdefd�Zdedefd�Z dedefd�Z dedefd�Z dedefd�Z dedefd �Z d edd fd �Zd S )� InfinityType�returnc � � dS )N�Infinity� ��selfs �r/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/_structures.py�__repr__zInfinityType.__repr__ s � ��z� c �: � t t | � � � � S �N��hash�reprr s r �__hash__zInfinityType.__hash__ � � ��D��J�J� � � r �otherc � � dS �NFr �r r s r �__lt__zInfinityType.__lt__ � � ��ur c � � dS r r r s r �__le__zInfinityType.__le__ r r c �, � t || j � � S r �� isinstance� __class__r s r �__eq__zInfinityType.__eq__ � � ��%�� �0�0�0r c � � dS �NTr r s r �__gt__zInfinityType.__gt__ � � ��tr c � � dS r# r r s r �__ge__zInfinityType.__ge__ r% r r �NegativeInfinityTypec � � t S r )�NegativeInfinityr s r �__neg__zInfinityType.__neg__ s � � � r N)�__name__� __module__� __qualname__�strr �intr �object�boolr r r r$ r' r+ r r r r r s � � � � � ��#� � � � � �#� � � � ��F� �t� � � � ��F� �t� � � � �1�F� 1�t� 1� 1� 1� 1��F� �t� � � � ��F� �t� � � � � �f� �!7� � � � � � r r c � � e Zd Zdefd�Zdefd�Zdedefd�Z dedefd�Z dedefd�Z dedefd�Z dedefd �Z d edefd �Zd S ) r( r c � � dS )Nz -Infinityr r s r r z NegativeInfinityType.__repr__$ s � ��{r c �: � t t | � � � � S r r r s r r z NegativeInfinityType.__hash__' r r r c � � dS r# r r s r r zNegativeInfinityType.__lt__* r% r c � � dS r# r r s r r zNegativeInfinityType.__le__- r% r c �, � t || j � � S r r r s r r zNegativeInfinityType.__eq__0 r! r c � � dS r r r s r r$ zNegativeInfinityType.__gt__3 r r c � � dS r r r s r r' zNegativeInfinityType.__ge__6 r r r c � � t S r )r r s r r+ z NegativeInfinityType.__neg__9 s � ��r N)r, r- r. r/ r r0 r r1 r2 r r r r$ r' r r+ r r r r( r( # s � � � � � ��#� � � � � �#� � � � ��F� �t� � � � ��F� �t� � � � �1�F� 1�t� 1� 1� 1� 1��F� �t� � � � ��F� �t� � � � ��f� � � � � � � � r r( N)r r r( r* r r r �<module>r< sy �� � � � � � � � �4 �<�>�>��� � � � � � � �4 (�'�)�)� � � r __pycache__/markers.cpython-311.pyc 0000644 00000030770 15004414131 0013122 0 ustar 00 � ]�bg�) � �� � U d dl mZ d dlZd dlZd dlZd dlZd dlmZmZm Z m Z ddl m Z m Z mZmZmZ ddl mZ ddlmZ ddlmZmZ dd lmZ g d �Zeeege f Z G d � d e � � Z G d � de � � Z G d� de � � Z! G d� de � � Z"d8d�Z# d9d:d �Z$d � d � ej% ej& ej' ej( ej) ej* d �Z+d!e,d"< d;d(�Z-d<d,�Z.d=d1�Z/d>d4�Z0d?d5�Z1 G d6� d7� � Z2dS )@� )� annotationsN)�Any�Callable� TypedDict�cast� )� MarkerAtom� MarkerList�Op�Value�Variable)� parse_marker)�ParserSyntaxError)�InvalidSpecifier� Specifier��canonicalize_name)� InvalidMarker�UndefinedComparison�UndefinedEnvironmentName�Marker�default_environmentc � � e Zd ZdZdS )r zE An invalid marker was found, users should refer to PEP 508. N��__name__� __module__� __qualname__�__doc__� � �n/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/markers.pyr r � � � � � � �� � � r r c � � e Zd ZdZdS )r zP An invalid operation was attempted on a value that doesn't support it. Nr r r r! r r $ r" r r c � � e Zd ZdZdS )r z\ A name was attempted to be used that does not exist inside of the environment. Nr r r r! r r * s � � � � � �� � � r r c � � e Zd ZU ded< ded< ded< ded< ded< ded< ded< ded < ded < ded < ded < d S )� Environment�str�implementation_name�implementation_version�os_name�platform_machine�platform_release�platform_system�platform_version�python_full_version� platform_python_implementation�python_version� sys_platformN)r r r �__annotations__r r r! r& r& 1 s� � � � � � � � � � � �>� � � � �� �L�L�L�� ����� ����� ����� ����� � � � �� (�'�'�'�� ����9������ r r& �resultsr �returnc �r � t | d t � � r�| d \ }}}t |t � � r/|j dk r$t |j � � }t |� � }nCt |t � � r.|j dk r#t |j � � }t |� � }|||f| d< | S )z! Normalize extra values. r �extra)� isinstance�tupler �valuer r )r4 �lhs�op�rhs�normalized_extras r! �_normalize_extra_valuesr? y s� � � �'�!�*�e�$�$� "� �q�z� ��R�� �c�8� $� $� *���g�)=�)=� 0��� ;� ;� ��(�)�)�C�C� ��X� &� &� *�3�9��+?�+?� 0��� ;� ;� ��(�)�)�C��"�c�\��� � �Nr T�marker� list[str] | MarkerAtom | str�first� bool | Noner' c � � t | t t t f� � sJ �t | t � � rJt | � � dk r7t | d t t f� � rt | d � � S t | t � � r>d� | D � � }|rd� |� � S dd� |� � z dz S t | t � � r d� d� | D � � � � S | S )Nr r c 3 �8 K � | ]}t |d �� � V � �dS )F)rB N)�_format_marker��.0�ms r! � <genexpr>z!_format_marker.<locals>.<genexpr>� s/ � � � �@�@�A� ���/�/�/�@�@�@�@�@�@r � �(�)c �6 � g | ]}|� � � ��S r )� serializerG s r! � <listcomp>z"_format_marker.<locals>.<listcomp>� s � �7�7�7�1���� � �7�7�7r )r8 �listr9 r' �lenrF �join)r@ rB �inners r! rF rF � s � � �f�t�U�C� 0� 1� 1�1�1� 1� �6�4� � �)� ��K�K�1� � � �v�a�y�4��-� 0� 0� � �f�Q�i�(�(�(��&�$� � � �@�@��@�@�@�� � /��8�8�E�?�?� "�����%� � �(�3�.� .� �F�E� "� "� ��x�x�7�7��7�7�7�8�8�8�� r c � � | |v S �Nr �r; r= s r! �<lambda>rX � s � �3�#�:� r c � � | |vS rV r rW s r! rX rX � s � �s�#�~� r )�inznot in�<z<=z==z!=z>=�>zdict[str, Operator]� _operatorsr; r< r r= �boolc �d � t d� |� � � |g� � � � }|� | d�� � S # t $ r Y nw xY wt � |� � � � � }|�t d|�d| �d|�d�� � � || |� � S )N� T)� prereleasesz Undefined z on z and �.)r rS rO �containsr r] �getr )r; r< r= �spec�opers r! �_eval_oprg � s� � �4�����"�,�,�.�.�#�!6�7�7�8�8�� �}�}�S�d�}�3�3�3�� � � � � �� ���� '�N�N�2�<�<�>�>� :� :�D� �|�!�"M�r�"M�"M��"M�"M�S�"M�"M�"M�N�N�N� �4��S�>�>�s �6A � A �A �values�key�tuple[str, ...]c �D � | dk rt d� |D � � � � S |S )Nr7 c 3 �4 K � | ]}t |� � V � �d S rV r )rH �vs r! rJ z _normalize.<locals>.<genexpr>� s+ � � � �:�:�a�&�q�)�)�:�:�:�:�:�:r )r9 )ri rh s r! � _normalizern � s1 � � �g�~�~��:�:�6�:�:�:�:�:�:� �Mr �markersr � environment�dict[str, str]c � � g g}| D �]%}t |t t t f� � sJ �t |t � � r*|d � t ||� � � � �ft |t � � r�|\ }}}t |t � � r|j }|| }|j } n|j }|j }|| } t || |�� � \ }} |d � t ||| � � � � ��|dv sJ �|dk r|� g � � ��'t d� |D � � � � S )N���)ri )�and�orru c 3 �4 K � | ]}t |� � V � �d S rV )�all)rH �items r! rJ z$_evaluate_markers.<locals>.<genexpr>� s( � � � �,�,�T�s�4�y�y�,�,�,�,�,�,r ) r8 rQ r9 r' �append�_evaluate_markersr r: rn rg �any) ro rp �groupsr@ r; r< r= �environment_key� lhs_value� rhs_values r! rz rz � sX � � "�t�F�� "� "���&�4���"4�5�5�5�5�5� �f�d� #� #� "� �2�J� � � /�� � D� D� E� E� E� E� ��� &� &� "�!�L�C��S��#�x�(�(� 9�"%�)�� '�� 8� � �I� � � �I� �"%�)�� '�� 8� �#-�i���#X�#X�#X� �I�y� �2�J� � �h�y�"�i� @� @� A� A� A� A��]�*�*�*�*���~�~�� � �b�!�!�!�� �,�,�V�,�,�,� ,� ,�,r �info�sys._version_infoc � � d� | � � }| j }|dk r ||d t | j � � z z }|S )Nz {0.major}.{0.minor}.{0.micro}�finalr )�format� releaselevelr' �serial)r� �version�kinds r! �format_full_versionr� � sH � �-�4�4�T�:�:�G� � �D� �w����4��7�S��� -� -�-�-�� �Nr c �� � t t j j � � } t j j }|| t j t j � � t j � � t j � � t j � � t j � � t j � � d� t j � � d d� � � t j d� S )Nrb � ) r( r) r* r+ r, r- r. r/ r0 r1 r2 )r� �sys�implementationr� �name�os�platform�machine�release�systemr1 �python_implementationrS �python_version_tuple)�iverr( s r! r r � s� � � �s� 1� 9� :� :�D� �,�1�� 2�"&��7� $� ,� .� .� $� ,� .� .�#�?�,�,� $� ,� .� .� '� 6� 8� 8�*2�*H�*J�*J� �(�(�8�#@�#B�#B�2�A�2�#F�G�G�� � � � r c �@ � e Zd Zdd�Zdd�Zdd�Zdd �Zdd �Zddd�ZdS )r r@ r' r5 �Nonec � � t t |� � � � | _ d S # t $ r"}t t |� � � � |�d }~ww xY wrV )r? � _parse_marker�_markersr r r' )�selfr@ �es r! �__init__zMarker.__init__ sY � � /� 3�M�&�4I�4I� J� J�D�M�M�M��" !� /� /� /� ��A���'�'�Q� .����� /���s �!% � A� A � Ac �* � t | j � � S rV )rF r� �r� s r! �__str__zMarker.__str__ s � � �d�m�,�,�,r c � � d| � d�S )Nz <Marker('z')>r r� s r! �__repr__zMarker.__repr__! s � �$�4�$�$�$�$r �intc �R � t | j j t | � � f� � S rV )�hash� __class__r r' r� s r! �__hash__zMarker.__hash__$ s � ��T�^�,�c�$�i�i�8�9�9�9r �otherr r^ c �z � t |t � � st S t | � � t |� � k S rV )r8 r �NotImplementedr' )r� r� s r! �__eq__z Marker.__eq__' s1 � ��%��(�(� "�!� !��4�y�y�C��J�J�&�&r Nrp �dict[str, str] | Nonec � � t dt � � � � }d|d< |d � d� � r|dxx dz cc< |�"|� |� � |d �d|d< t | j |� � S )a$ Evaluate a marker. Return the boolean from evaluating the given marker against the environment. environment is an optional argument to override all or part of the determined environment. The environment is determined from the current Python process. rq r` r7 r/ �+�local)r r �endswith�updaterz r� )r� rp �current_environments r! �evaluatezMarker.evaluate- s� � � #�#3�5H�5J�5J� K� K��')��G�$� � 4� 5� >� >�s� C� C� B� � 5� 6� 6� 6�'� A� 6� 6� 6� � "� � &� &�{� 3� 3� 3� #�7�+�3�/1�#�G�,� �� �0C�D�D�Dr )r@ r' r5 r� )r5 r' )r5 r� )r� r r5 r^ rV )rp r� r5 r^ ) r r r r� r� r� r� r� r� r r r! r r s� � � � � � �/� /� /� /�2-� -� -� -�%� %� %� %�:� :� :� :�'� '� '� '� E� E� E� E� E� E� Er r )r4 r r5 r )T)r@ rA rB rC r5 r' )r; r' r< r r= r' r5 r^ )rh r' ri r' r5 rj )ro r rp rq r5 r^ )r� r� r5 r' )r5 r& )3� __future__r �operatorr� r� r� �typingr r r r �_parserr r r r r r r� � _tokenizerr � specifiersr r �utilsr �__all__r' r^ �Operator� ValueErrorr r r r& r? rF �lt�le�eq�ne�ge�gtr] r3 rg rn rz r� r r r r r! �<module>r� s� �� #� "� "� "� "� "� "� ���� � � � � ���� � � � � 1� 1� 1� 1� 1� 1� 1� 1� 1� 1� 1� 1� @� @� @� @� @� @� @� @� @� @� @� @� @� @� 2� 2� 2� 2� 2� 2� )� )� )� )� )� )� 3� 3� 3� 3� 3� 3� 3� 3� $� $� $� $� $� $� � � �� �S�#�J��$� %��� � � � �J� � � � � � � � �*� � � � � � � � �z� � � �E� E� E� E� E�)� E� E� E�P � � � �" @D�� � � � �: &� %�-�-� �� �+� �+� �+� �+� �� #� #� � � � � � � � � � � � � �-� -� -� -�<� � � �� � � �$AE� AE� AE� AE� AE� AE� AE� AE� AE� AEr __pycache__/requirements.cpython-311.pyc 0000644 00000011211 15004414131 0014166 0 ustar 00 � ]�bg� � � � d dl mZ d dlmZmZ ddlmZ ddlm Z ddl m Z m Z ddl mZ ddlmZ G d � d e� � Z G d � d � � Zd S )� )� annotations)�Any�Iterator� )�parse_requirement)�ParserSyntaxError)�Marker�_normalize_extra_values)� SpecifierSet)�canonicalize_namec � � e Zd ZdZdS )�InvalidRequirementzJ An invalid requirement was found, users should refer to PEP 508. N)�__name__� __module__� __qualname__�__doc__� � �s/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/requirements.pyr r s � � � � � �� � � r r c �B � e Zd ZdZdd�Zdd �Zdd �Zdd �Zdd �Zdd�Z dS )� Requirementz�Parse a requirement. Parse a given requirement string into its parts, such as name, specifier, URL, and extras. Raises InvalidRequirement on a badly-formed requirement string. �requirement_string�str�return�Nonec � � t |� � }n/# t $ r"}t t |� � � � |�d }~ww xY w|j | _ |j pd | _ t |j pg � � | _ t |j � � | _ d | _ |j �>t j t � � | _ t |j � � | j _ d S d S �N)�_parse_requirementr r r �name�url�set�extrasr � specifier�markerr �__new__r �_markers)�selfr �parsed�es r �__init__zRequirement.__init__" s� � � 4�'�(:�;�;�F�F�� � 4� 4� 4�$�S��V�V�,�,�!� 3����� 4���� ��� � %�z� 1�T��� #�F�M�$7�R� 8� 8�� �'3�F�4D�'E�'E���%)�� � �=� $� �.��0�0�D�K�#:�6�=�#I�#I�D�K� � � � %� $s � � >� 9�>r � Iterator[str]c # � K � |V � | j r/d� t | j � � � � }d|� d�V � | j rt | j � � V � | j rd| j � �V � | j rdV � | j rd| j � �V � d S d S )N�,�[�]z@ � z; )r" �join�sortedr# r r r$ )r' r �formatted_extrass r � _iter_partszRequirement._iter_parts1 s� � � � �� � � � �;� *� "�x�x��t�{�(;�(;� <� <� �)�&�)�)�)� )� )� )� �>� &��d�n�%�%� %� %� %� �8� �!�t�x�/�/� !� !� !��{� �� � � � �;� %�$�t�{�$�$� $� $� $� $� $� %� %r c �\ � d� | � | j � � � � S )N� )r1 r4 r �r' s r �__str__zRequirement.__str__C s$ � ��w�w�t�'�'�� �2�2�3�3�3r c � � d| � d�S )Nz<Requirement('z')>r r7 s r �__repr__zRequirement.__repr__F s � �)��)�)�)�)r �intc � � t | j j g| � t | j � � � � �R � � S r )�hash� __class__r r4 r r r7 s r �__hash__zRequirement.__hash__I sG � ����'� ��!�!�"3�D�I�">�">�?�?� � � � � r �otherr �boolc � � t |t � � st S t | j � � t |j � � k o?| j |j k o/| j |j k o | j |j k o| j |j k S r ) � isinstancer �NotImplementedr r r" r# r r$ )r' r@ s r �__eq__zRequirement.__eq__Q s� � ��%��-�-� "�!� !� �d�i� (� (�,=�e�j�,I�,I� I� ,�� �u�|�+� ,���%�/�1� ,� ��E�I�%� ,� � �u�|�+� r N)r r r r )r r r r+ )r r )r r; )r@ r r rA ) r r r r r* r4 r8 r: r? rE r r r r r s� � � � � � �� � J� J� J� J� %� %� %� %�$4� 4� 4� 4�*� *� *� *� � � � � � � � � � r r N)� __future__r �typingr r �_parserr r � _tokenizerr �markersr r � specifiersr �utilsr � ValueErrorr r r r r �<module>rN s� �� #� "� "� "� "� "� � � � � � � � � <� <� <� <� <� <� )� )� )� )� )� )� 4� 4� 4� 4� 4� 4� 4� 4� $� $� $� $� $� $� $� $� $� $� $� $�� � � � �� � � � F � F � F � F � F � F � F � F � F � F r __pycache__/specifiers.cpython-311.pyc 0000644 00000120500 15004414131 0013601 0 ustar 00 � ]�bg:� � �l � d Z ddlmZ ddlZddlZddlZddlmZmZm Z m Z m Z ddl m Z ddlmZ e eef Z e de� � � Zeeegef Zd%d�Z G d� de� � Z G d� dej �� � Z G d� de� � Z ej d� � Z d&d�Z d'd�Z d(d �Z d)d"�Z G d#� d$e� � Z!dS )*z� .. testsetup:: from pip._vendor.packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from pip._vendor.packaging.version import Version � )� annotationsN)�Callable�Iterable�Iterator�TypeVar�Union� )�canonicalize_version)�Version�UnparsedVersionVar)�bound�version�UnparsedVersion�returnr c �N � t | t � � st | � � } | S �N)� isinstancer )r s �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/specifiers.py�_coerce_versionr s& � � �g�w� '� '� #��'�"�"�� �N� c � � e Zd ZdZdS )�InvalidSpecifiera Raised when attempting to create a :class:`Specifier` with a specifier string that is invalid. >>> Specifier("lolwat") Traceback (most recent call last): ... packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' N)�__name__� __module__� __qualname__�__doc__� r r r r s � � � � � �� � � r r c � � e Zd Zej dd�� � Zej dd�� � Zej dd �� � Zeej dd �� � � � Z e j dd�� � Z ej d d d�� � Z ej d d d�� � Z dS ) � BaseSpecifierr �strc � � dS )z� Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr ��selfs r �__str__zBaseSpecifier.__str__- � � � � r �intc � � dS )zF Returns a hash value for this Specifier-like object. Nr r" s r �__hash__zBaseSpecifier.__hash__4 r% r �other�object�boolc � � dS )z� Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nr �r# r) s r �__eq__zBaseSpecifier.__eq__: r% r � bool | Nonec � � dS )z�Whether or not pre-releases as a whole are allowed. This can be set to either ``True`` or ``False`` to explicitly enable or disable prereleases or it can be set to ``None`` (the default) to use default semantics. Nr r" s r � prereleaseszBaseSpecifier.prereleasesC r% r �value�Nonec � � dS )zQSetter for :attr:`prereleases`. :param value: The value to set. Nr �r# r2 s r r1 zBaseSpecifier.prereleasesL r% r N�itemr1 c � � dS )zR Determines if the given item is contained within this specifier. Nr )r# r6 r1 s r �containszBaseSpecifier.containsS r% r �iterable� Iterable[UnparsedVersionVar]� Iterator[UnparsedVersionVar]c � � dS )z� Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr )r# r9 r1 s r �filterzBaseSpecifier.filterY r% r �r r �r r& �r) r* r r+ �r r/ �r2 r+ r r3 r )r6 r r1 r/ r r+ �r9 r: r1 r/ r r; ) r r r �abc�abstractmethodr$ r( r. �propertyr1 �setterr8 r= r r r r r , s% � � � � � ��� � � � �� � �� � � � �� � �� � � � �� � ��� � � � �� �X� � �� � � � �� � �� � � � � �� � ��QU� � � � � �� � � r r )� metaclassc � � e Zd ZdZdZdZ ej dez ez dz ej ej z � � Z dddd d d d d d�Z d>d?d�Z e d@d�� � Zej dAd�� � Ze dBd �� � Ze dBd �� � ZdBd �ZdBd �Ze dCd!�� � ZdDd#�ZdEd&�ZdFd)�ZdGd,�ZdGd-�ZdGd.�ZdGd/�ZdGd0�Z dHd2�Z dHd3�Z dGd4�Z dId7�Z dJdKd9�Z! dJdLd=�Z"dS )M� Specifiera? This class abstracts handling of version specifiers. .. tip:: It is generally not required to instantiate this manually. You should instead prefer to work with :class:`SpecifierSet` instead, which can parse comma-separated version specifiers (which is what package metadata contains). z8 (?P<operator>(~=|==|!=|<=|>=|<|>|===)) a� (?P<version> (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. (?<====) # Only match for the identity operator \s* [^\s;)]* # The arbitrary version can be just about anything, # we match everything except for whitespace, a # semi-colon for marker support, and a closing paren # since versions can be enclosed in them. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?<===|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release # You cannot use a wild card and a pre-release, post-release, a dev or # local version together so group them with a | and make them optional. (?: \.\* # Wild card syntax of .* | (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?<=~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?<!==|!=|~=) # We have special cases for these # operators so we want to make sure they # don't match here. \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) ) z^\s*z\s*$� compatible�equal� not_equal�less_than_equal�greater_than_equal� less_than� greater_than� arbitrary)�~=�==z!=�<=�>=�<�>�===� N�specr r1 r/ r r3 c � � | j � |� � }|st d|� d�� � �|� d� � � � � |� d� � � � � f| _ || _ dS )a� Initialize a Specifier instance. :param spec: The string representation of a specifier which will be parsed and normalized before use. :param prereleases: This tells the specifier if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given specifier is invalid (i.e. bad syntax). zInvalid specifier: '�'�operatorr N)�_regex�searchr �group�strip�_spec� _prereleases)r# r[ r1 �matchs r �__init__zSpecifier.__init__� s� � � � �"�"�4�(�(��� C�"�#A�$�#A�#A�#A�B�B� B� �K�K� � #� #� )� )� +� +� �K�K� � "� "� (� (� *� *�' �� � (����r r+ c � � | j �| j S | j \ }}|dv r;|dk r |� d� � r |d d� }t |� � j rdS dS )N)rT rV rU rS rY rT �.*���TF)rd rc �endswithr � is_prerelease)r# r^ r s r r1 zSpecifier.prereleases� s| � � � � (��$� $� !�J���'� �6� 6� 6� �4� � �G�$4�$4�T�$:�$:� �!�#�2�#�,�� �w� � �-� ��t��ur r2 c � � || _ d S r �rd r5 s r r1 zSpecifier.prereleases � � � !����r c � � | j d S )z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' r �rc r" s r r^ zSpecifier.operator � � � �z�!�}� r c � � | j d S )zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rp r" s r r zSpecifier.version rq r c �l � | j � d| j ��nd}d| j j � dt | � � �|� d�S )aT A representation of the Specifier that shows all internal state. >>> Specifier('>=1.0.0') <Specifier('>=1.0.0')> >>> Specifier('>=1.0.0', prereleases=False) <Specifier('>=1.0.0', prereleases=False)> >>> Specifier('>=1.0.0', prereleases=True) <Specifier('>=1.0.0', prereleases=True)> N�, prereleases=rZ rW �(�)>)rd r1 � __class__r r �r# �pres r �__repr__zSpecifier.__repr__& sT � � � �,� 2�T� -� 1� 1� 1�� � B�4�>�*�A�A�S��Y�Y�A�#�A�A�A�Ar c � � dj | j � S )z�A string representation of the Specifier that can be round-tripped. >>> str(Specifier('>=1.0.0')) '>=1.0.0' >>> str(Specifier('>=1.0.0', prereleases=False)) '>=1.0.0' z{}{})�formatrc r" s r r$ zSpecifier.__str__8 s � � �v�}�d�j�)�)r �tuple[str, str]c �v � t | j d | j d dk �� � }| j d |fS )Nr r rS ��strip_trailing_zero)r rc )r# �canonical_versions r �_canonical_speczSpecifier._canonical_specB sB � � 0� �J�q�M�!%��A� �$�!6� � � �� �z�!�}� /�/�/r r& c �* � t | j � � S r )�hashr� r" s r r( zSpecifier.__hash__J s � ��D�(�)�)�)r r) r* c � � t |t � � r; | � t |� � � � }n3# t $ r t cY S w xY wt || j � � st S | j |j k S )a> Whether or not the two Specifier-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") True >>> (Specifier("==1.2.3", prereleases=False) == ... Specifier("==1.2.3", prereleases=True)) True >>> Specifier("==1.2.3") == "==1.2.3" True >>> Specifier("==1.2.3") == Specifier("==1.2.4") False >>> Specifier("==1.2.3") == Specifier("~=1.2.3") False )r r rw r �NotImplementedr� r- s r r. zSpecifier.__eq__M s� � �& �e�S� !� !� "� &� ���s�5�z�z�2�2����#� &� &� &�%�%�%�%� &�����E�4�>�2�2� "�!� !��#�u�'<�<�<s �": �A� A�op�CallableOperatorc �B � t | d| j | � �� � }|S )N� _compare_)�getattr� _operators)r# r� �operator_callables r � _get_operatorzSpecifier._get_operatorj s/ � �.5� �3�d�o�b� 1�3�3�/ � / �� !� r � prospectiver c � � t t t j t t |� � � � � � d d� � � }|dz } | � d� � ||� � o | � d� � ||� � S )N���rh rV rT )� _version_join�list� itertools� takewhile�_is_not_suffix�_version_splitr� )r# r� r[ �prefixs r �_compare_compatiblez Specifier._compare_compatiblep s� � � � ��$�^�^�D�5I�5I�J�J� K� K�C�R�C� P� � �� �$���'�t�!�!�$�'�'� �T�:�:� �?W�t�?Q�?Q�RV�?W�?W� ��@ � @ � r c � � |� d� � r}t |j d�� � }t |d d� d�� � }t |� � }t |� � }t ||� � \ }}|d t |� � � } | |k S t |� � } | j st |j � � }|| k S )Nrh Fr ri )rj r �publicr� � _pad_version�lenr �local) r# r� r[ �normalized_prospective�normalized_spec� split_spec�split_prospective�padded_prospective�_�shortened_prospective� spec_versions r �_compare_equalzSpecifier._compare_equal� s� � � �=�=�� � � $ /�%9��"��&� &� &� "� 3�4����9�RW� X� X� X�O� (��8�8�J� !/�/E� F� F� � %1�1B�J�$O�$O� !� �� %7�7H��Z� � �7H�$I� !�(�J�6� 6� #�4�=�=�L� �%� :� %�k�&8� 9� 9� � �,�.� .r c �0 � | � ||� � S r )r� �r# r� r[ s r �_compare_not_equalz Specifier._compare_not_equal� s � ��&�&�{�D�9�9�9�9r c �L � t |j � � t |� � k S r �r r� r� s r �_compare_less_than_equalz"Specifier._compare_less_than_equal� � � � �{�)�*�*�g�d�m�m�;�;r c �L � t |j � � t |� � k S r r� r� s r �_compare_greater_than_equalz%Specifier._compare_greater_than_equal� r� r �spec_strc � � t |� � }||k sdS |j s3|j r,t |j � � t |j � � k rdS dS �NFT)r rk � base_version�r# r� r� r[ s r �_compare_less_thanz Specifier._compare_less_than� sg � � �x� � �� �T�!�!��5� �!� �k�&?� ��{�/�0�0�G�D�<M�4N�4N�N�N� �u� �tr c � � t |� � }||k sdS |j s3|j r,t |j � � t |j � � k rdS |j �,t |j � � t |j � � k rdS dS r� )r �is_postreleaser� r� r� s r �_compare_greater_thanz Specifier._compare_greater_than� s� � � �x� � �� �T�!�!��5� �"� �{�'A� ��{�/�0�0�G�D�<M�4N�4N�N�N� �u� � � (��{�/�0�0�G�D�<M�4N�4N�N�N� �u� �tr c � � t |� � � � � t |� � � � � k S r )r �lowerr� s r �_compare_arbitraryz Specifier._compare_arbitrary� s1 � ��;� � �%�%�'�'�3�t�9�9�?�?�+<�+<�<�<r r6 � str | Versionc �, � | � |� � S )a; Return whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in Specifier(">=1.2.3") True >>> Version("1.2.3") in Specifier(">=1.2.3") True >>> "1.0.0" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True �r8 �r# r6 s r � __contains__zSpecifier.__contains__� � � �& �}�}�T�"�"�"r r c � � |�| j }t |� � }|j r|sdS | � | j � � } ||| j � � S )al Return whether or not the item is contained in this specifier. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this Specifier. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> Specifier(">=1.2.3").contains("1.2.3") True >>> Specifier(">=1.2.3").contains(Version("1.2.3")) True >>> Specifier(">=1.2.3").contains("1.0.0") False >>> Specifier(">=1.2.3").contains("1.3.0a1") False >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") True >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) True NF)r1 r rk r� r^ r )r# r6 r1 �normalized_itemr� s r r8 zSpecifier.contains sg � �4 � � �*�K� *�$�/�/�� � (� �� ��5� /3�.@�.@�� �.O�.O�� � � �$�,�?�?�?r r9 r: r; c # �� K � d}g }d|�|ndi}|D ]K}t |� � } | j |fi |��r,|j r |s | j s|� |� � �Ed}|V � �L|s |r |D ] }|V � �dS dS dS )aO Filter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(Specifier().contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) ['1.2.3', '1.3', <Version('1.4')>] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) ['1.5a1'] >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] Fr1 NT)r r8 rk r1 �append)r# r9 r1 �yielded�found_prereleases�kwr �parsed_versions r r= zSpecifier.filter5 s� � � � �< �� ���K�,C�[�[�� N�� � "� "�G� ,�W� 5� 5�N� �t�}�^�2�2�r�2�2� "� "�/� "� �"�#'�#3�"� &�,�,�W�5�5�5�5� #�G�!�M�M�M�� � �,� �,� � �� � � � � � � � � � � r �rZ N)r[ r r1 r/ r r3 )r r+ rB r> )r r} r? r@ )r� r r r� )r� r r[ r r r+ )r� r r� r r r+ )r6 r� r r+ r )r6 r r1 r/ r r+ rC )#r r r r �_operator_regex_str�_version_regex_str�re�compile�VERBOSE� IGNORECASEr_ r� rf rF r1 rG r^ r rz r$ r� r( r. r� r� r� r� r� r� r� r� r� r� r8 r= r r r rJ rJ c s� � � � � � �� � ��\ ��| �R�Z��%�%�(:�:�W�D� � �R�]�"�� �F� ��� �"� � �� � �J�(� (� (� (� (�4 �� � � �X��. ��"� "� "� ��"� � � � � �X� � � � � � �X� �B� B� B� B�$*� *� *� *� �0� 0� 0� �X�0�*� *� *� *�=� =� =� =�:!� !� !� !� � � � �(&/� &/� &/� &/�P:� :� :� :�<� <� <� <� <� <� <� <� � � � �0 � � � �<=� =� =� =�#� #� #� #�**@� *@� *@� *@� *@�Z RV�; � ; � ; � ; � ; � ; � ; r rJ z ^([0-9]+)((?:a|b|c|rc)[0-9]+)$r � list[str]c �L � g }| � d� � \ }}}|� |pd� � |� d� � D ][}t � |� � }|r(|� |� � � � � �F|� |� � �\|S )a Split version into components. The split components are intended for version comparison. The logic does not attempt to retain the original version string, so joining the components back with :func:`_version_join` may not produce the original version string. �!�0�.)� rpartitionr� �split� _prefix_regexr` �extend�groups)r �result�epochr� �restr6 re s r r� r� v s� � � �F� �'�'��,�,�N�E�1�d� �M�M�%�,�3� � � �� � �3��� � �� �$�$�T�*�*�� � � �M�M�%�,�,�.�.� )� )� )� )� �M�M�$� � � � � �Mr � componentsc �> � | ^}}|� dd� |� � � �S )z�Join split version components into a version string. This function assumes the input came from :func:`_version_split`, where the first component must be the epoch (either empty or numeric), and all other components numeric. r� r� )�join)r� r� r� s r r� r� � s+ � � �L�E�D�� &� &�c�h�h�t�n�n� &� &�&r �segmentr+ c �< � � t � fd�dD � � � � S )Nc 3 �B �K � | ]}�� |� � V � �d S r )� startswith)�.0r� r� s �r � <genexpr>z!_is_not_suffix.<locals>.<genexpr>� sB �� � � � � �'-����6�"�"�� � � � � r )�dev�a�b�rc�post)�any)r� s `r r� r� � s@ �� �� � � � �1P�� � � � � � r �left�right�tuple[list[str], list[str]]c � � g g }}|� t t j d� | � � � � � � |� t t j d� |� � � � � � |� | t |d � � d � � � |� |t |d � � d � � � |� ddgt dt |d � � t |d � � z � � z � � |� ddgt dt |d � � t |d � � z � � z � � t t j � |� � � � t t j � |� � � � fS )Nc �* � | � � � S r ��isdigit��xs r �<lambda>z _pad_version.<locals>.<lambda>� s � ������ r c �* � | � � � S r r� r� s r r� z _pad_version.<locals>.<lambda>� s � �!�)�)�+�+� r r r r� ) r� r� r� r� r� �insert�max�chain� from_iterable)r� r� � left_split� right_splits r r� r� � s� � � �"� �J� ���d�9�.�/D�/D�d�K�K�L�L�M�M�M����t�I� /�0E�0E�u� M� M�N�N�O�O�O� ���d�3�z�!�}�-�-�/�/�0�1�1�1����u�S��Q� � 0� 0� 2� 2�3�4�4�4� ���a�#���Q��K��N�(;�(;�c�*�Q�-�>P�>P�(P�!Q�!Q�Q�R�R�R����q�3�%�#�a��Z��]�);�);�c�+�a�.�>Q�>Q�)Q�"R�"R�R�S�S�S� �Y�_� *� *�:� 6� 6�7�7� �Y�_� *� *�;� 7� 7�8�8� � r c � � e Zd ZdZd$d%d �Zed&d �� � Zej d'd�� � Zd(d�Zd(d�Z d)d�Z d*d�Z d+d�Z d)d�Z d,d�Zd-d �Z d.d/d �Z d0d1d#�ZdS )2� SpecifierSetz�This class abstracts handling of a set of version specifiers. It can be passed a single specifier (``>=3.0``), a comma-separated list of specifiers (``>=3.0,!=3.1``), or no specifier at all. rZ N� specifiersr r1 r/ r r3 c � � d� |� d� � D � � }t t t |� � � � | _ || _ dS )aN Initialize a SpecifierSet instance. :param specifiers: The string representation of a specifier or a comma-separated list of specifiers which will be parsed and normalized before use. :param prereleases: This tells the SpecifierSet if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given ``specifiers`` are not parseable than this exception will be raised. c �^ � g | ]*}|� � � �|� � � ��+S r )rb �r� �ss r � <listcomp>z)SpecifierSet.__init__.<locals>.<listcomp>� s- � �R�R�R�!���� � �R�A�G�G�I�I�R�R�Rr �,N)r� � frozenset�maprJ �_specsrd )r# r r1 �split_specifierss r rf zSpecifierSet.__init__� sS � �$ S�R�z�/?�/?��/D�/D�R�R�R�� ��I�/?� @� @�A�A�� � (����r c �l � | j �| j S | j sd S t d� | j D � � � � S )Nc 3 �$ K � | ] }|j V � � d S r �r1 r s r r� z+SpecifierSet.prereleases.<locals>.<genexpr>� s$ � � � �6�6�Q�1�=�6�6�6�6�6�6r )rd r r� r" s r r1 zSpecifierSet.prereleases� sH � � � � (��$� $� �{� ��4� �6�6�$�+�6�6�6�6�6�6r r2 r+ c � � || _ d S r rm r5 s r r1 zSpecifierSet.prereleases� rn r c �R � | j � d| j ��nd}dt | � � �|� d�S )a A representation of the specifier set that shows all internal state. Note that the ordering of the individual specifiers within the set may not match the input string. >>> SpecifierSet('>=1.0.0,!=2.0.0') <SpecifierSet('!=2.0.0,>=1.0.0')> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) <SpecifierSet('!=2.0.0,>=1.0.0', prereleases=False)> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) <SpecifierSet('!=2.0.0,>=1.0.0', prereleases=True)> Nrt rZ z<SpecifierSet(rv )rd r1 r rx s r rz zSpecifierSet.__repr__� sF � � � �,� 2�T� -� 1� 1� 1�� � 5��D� � �4�S�4�4�4�4r c �d � d� t d� | j D � � � � � � S )an A string representation of the specifier set that can be round-tripped. Note that the ordering of the individual specifiers within the set may not match the input string. >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) '!=1.0.1,>=1.0.0' >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) '!=1.0.1,>=1.0.0' r c 3 �4 K � | ]}t |� � V � �d S r )r r s r r� z'SpecifierSet.__str__.<locals>.<genexpr> s( � � � � ;� ;�!�s�1�v�v� ;� ;� ;� ;� ;� ;r )r� �sortedr r" s r r$ zSpecifierSet.__str__� s/ � � �x�x�� ;� ;�t�{� ;� ;� ;�;�;�<�<�<r r& c �* � t | j � � S r )r� r r" s r r( zSpecifierSet.__hash__ s � ��D�K� � � r r) �SpecifierSet | strc � � t |t � � rt |� � }n t |t � � st S t � � }t | j |j z � � |_ | j �|j � |j |_ nG| j �|j � | j |_ n,| j |j k r | j |_ nt d� � �|S )a� Return a SpecifierSet which is a combination of the two sets. :param other: The other object to combine with. >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' <SpecifierSet('!=1.0.1,!=2.0.1,<=2.0.0,>=1.0.0')> >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') <SpecifierSet('!=1.0.1,!=2.0.1,<=2.0.0,>=1.0.0')> NzFCannot combine SpecifierSets with True and False prerelease overrides.)r r r r� r r rd � ValueError)r# r) � specifiers r �__and__zSpecifierSet.__and__ s� � � �e�S� !� !� "� ��'�'�E�E��E�<�0�0� "�!� !� �N�N� �$�T�[�5�<�%?�@�@� �� � � $��);�)G�%*�%7�I� "� "� � � *�u�/A�/I�%)�%6�I� "� "� � �%�"4� 4� 4�%)�%6�I� "� "� � �� � � �r r* c �� � t |t t f� � r t t |� � � � }n t |t � � st S | j |j k S )a� Whether or not the two SpecifierSet-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") True >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) True >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" True >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") False >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") False )r r rJ r r� r r- s r r. zSpecifierSet.__eq__. sW � �& �e�c�9� -� .� .� "� ��U���,�,�E�E��E�<�0�0� "�!� !��{�e�l�*�*r c �* � t | j � � S )z7Returns the number of specifiers in this specifier set.)r� r r" s r �__len__zSpecifierSet.__len__H s � ��4�;� � � r �Iterator[Specifier]c �* � t | j � � S )z� Returns an iterator over all the underlying :class:`Specifier` instances in this specifier set. >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) [<Specifier('!=1.0.1')>, <Specifier('>=1.0.0')>] )�iterr r" s r �__iter__zSpecifierSet.__iter__L s � � �D�K� � � r r6 r c �, � | � |� � S )ar Return whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") True >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") True >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True r� r� s r r� zSpecifierSet.__contains__V r� r � installedc �� ��� t �t � � st �� � ���| j ��s �j rdS |r�j rt �j � � �t ��fd�| j D � � � � S )a� Return whether or not the item is contained in this SpecifierSet. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this SpecifierSet. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") False >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True NFc 3 �F �K � | ]}|� ��� � � V � � dS )r Nr� )r� r r6 r1 s ��r r� z(SpecifierSet.contains.<locals>.<genexpr>� s3 �� � � �R�R��1�:�:�d� �:�<�<�R�R�R�R�R�Rr )r r r1 rk r� �allr )r# r6 r1 r" s `` r r8 zSpecifierSet.containsk s� ��� �< �$��(�(� !��4�=�=�D� � � �*�K� � �t� 1� ��5� � .��+� .��4�,�-�-�D� �R�R�R�R�R�d�k�R�R�R�R�R�Rr r9 r: r; c � � |�| j }| j r=| j D ]&}|� |t |� � �� � }�'t |� � S g }g }|D ]G}t |� � }|j r|s|s|� |� � �2|� |� � �H|s|r|�t |� � S t |� � S )a. Filter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) ['1.3', <Version('1.4')>] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) [] >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] An "empty" SpecifierSet will filter items based on the presence of prerelease versions in the set. >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet("").filter(["1.5a1"])) ['1.5a1'] >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] Nr )r1 r r= r+ r r rk r� )r# r9 r1 r[ �filteredr� r6 r� s r r= zSpecifierSet.filter� s� � �X � � �*�K� �;� "� � � P� P�� �;�;�x�T�+�=N�=N�;�O�O�����>�>� !� 24�H�:<� � � *� *��!0��!6�!6�� "�/� *� � *�#� 7�)�0�0��6�6�6�� �O�O�D�)�)�)�)� � /� 1� /�k�6I�� -�.�.�.���>�>� !r r� )r r r1 r/ r r3 rA rB r> r? )r) r r r r@ )r r )r6 r r r+ )NN)r6 r r1 r/ r" r/ r r+ r rC )r r r r rf rF r1 rG rz r$ r( r r. r r r� r8 r= r r r r r � sj � � � � � �� � (� (� (� (� (�6 �7� 7� 7� �X�7� ��"� "� "� ��"�5� 5� 5� 5�* =� =� =� =�!� !� !� !� � � � �@+� +� +� +�4 � � � �!� !� !� !�#� #� #� #�0 $(�!%� 7S� 7S� 7S� 7S� 7S�t RV�M"� M"� M"� M"� M"� M"� M"r r )r r r r )r r r r� )r� r� r r )r� r r r+ )r� r� r� r� r r� )"r � __future__r rD r� r� �typingr r r r r �utilsr r r r r r r+ r� r r r �ABCMetar rJ r� r� r� r� r� r� r r r r �<module>r, s ��� � #� "� "� "� "� "� � � � � � � � � � � � � ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� '� '� '� '� '� '� � � � � � ���� �%�� �W� 1� �I�I�I� ��W�c�N�D� 0�1� �� � � � � � � � �z� � � �4 � 4 � 4 � 4 � 4 �c�k� 4 � 4 � 4 � 4 �nM � M � M � M � M � � M � M � M �` �� �<�=�=� �� � � �,'� '� '� '�� � � � � � � �*"� "� "� "� "�=� "� "� "� "� "r __pycache__/tags.cpython-311.pyc 0000644 00000063115 15004414131 0012413 0 ustar 00 � ]�bg�S � � � U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl m Z d dl m Z m Z mZmZmZ ddlmZmZ ej e� � Zee Zeeef Zddd d d d �Zd ed< ej d� � dk Z G d� d� � Z dHd�Z dIdJd �Z dKd �Z!dLd"�Z"dMd&�Z#dIdNd(�Z$ dOdd)�dPd.�Z%dQd/�Z& dOdd)�dRd2�Z'dSd4�Z( dOdTd5�Z)e fdUd8�Z*dVd<�Z+ dWdXd>�Z, dWdYd@�Z-e fdZdA�Z.d[dB�Z/d[dC�Z0d\dD�Z1dd)�d]dE�Z2d^dF�Z3dd)�d_dG�Z4dS )`� )� annotationsN)�EXTENSION_SUFFIXES)�Iterable�Iterator�Sequence�Tuple�cast� )� _manylinux� _musllinux�py�cp�pp�ip�jy)�python�cpython�pypy� ironpython�jythonzdict[str, str]�INTERPRETER_SHORT_NAMES�P� c � � e Zd ZdZg d�Zdd �Zedd �� � Zedd �� � Zedd �� � Z dd�Z dd�Z dd�Z dd�Z dS )�Tagz� A representation of the tag triple for a wheel. Instances are considered immutable and thus are hashable. Equality checking is also supported. )� _interpreter�_abi� _platform�_hash� interpreter�str�abi�platform�return�Nonec �� � |� � � | _ |� � � | _ |j � � | _ t | j | j | j f� � | _ d S �N)�lowerr r r �hashr )�selfr r" r# s �k/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/tags.py�__init__z Tag.__init__4 sY � � '� -� -� /� /����I�I�K�K�� �'�� �)�)��� �4�,�d�i�� �H�I�I�� � � � c � � | j S r' )r �r* s r+ r zTag.interpreter? s � �� � r- c � � | j S r' )r r/ s r+ r" zTag.abiC s � ��y�r- c � � | j S r' )r r/ s r+ r# z Tag.platformG s � ��~� r- �other�object�boolc � � t |t � � st S | j |j k o/| j |j k o | j |j k o| j |j k S r' )� isinstancer �NotImplementedr r r r )r* r2 s r+ �__eq__z Tag.__eq__K sd � ��%��%�%� "�!� !� �Z�5�;� &� :�� �5�?�2� :���e�j�(� :� �"�e�&8�8� r- �intc � � | j S r' )r r/ s r+ �__hash__z Tag.__hash__V s � ��z�r- c �4 � | j � d| j � d| j � �S )N�-)r r r r/ s r+ �__str__z Tag.__str__Y s% � ��#�B�B�d�i�B�B�$�.�B�B�Br- c �. � d| � dt | � � � d�S )N�<z @ �>)�idr/ s r+ �__repr__z Tag.__repr__\ s! � �'�4�'�'�B�t�H�H�'�'�'�'r- N)r r! r" r! r# r! r$ r% �r$ r! )r2 r3 r$ r4 )r$ r9 )�__name__� __module__� __qualname__�__doc__� __slots__r, �propertyr r" r# r8 r; r> rC � r- r+ r r * s� � � � � � �� � ?�>�>�I� J� J� J� J� �!� !� !� �X�!� �� � � �X�� � � � � �X� � � � � �� � � �C� C� C� C�(� (� (� (� (� (r- r �tagr! r$ �frozenset[Tag]c �F � t � � }| � d� � \ }}}|� d� � D ]V}|� d� � D ]>}|� d� � D ]&}|� t |||� � � � �'�?�Wt |� � S )z� Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. Returning a set is required due to the possibility that the tag is a compressed tag set. r= �.)�set�split�addr � frozenset)rL �tags� interpreters�abis� platformsr r" � platform_s r+ � parse_tagrY ` s� � � �5�5�D�$'�I�I�c�N�N�!�L�$� �#�)�)�#�.�.� ;� ;� ��:�:�c�?�?� ;� ;�C� &�_�_�S� 1� 1� ;� ;� �����[�#�y�9�9�:�:�:�:� ;� ;� �T�?�?�r- F�name�warnr4 �int | str | Nonec �l � t j | � � }|� |rt � d| � � |S )Nz>Config variable '%s' is unset, Python ABI tag may be incorrect)� sysconfig�get_config_var�logger�debug)rZ r[ �values r+ �_get_config_varrc p s= � � '� 6�t� <� <�E� �}��}�� � � L�d� � � � �Lr- �stringc �~ � | � dd� � � dd� � � dd� � S )NrO �_r= � )�replace)rd s r+ �_normalize_stringri y s6 � � �>�>�#�s� #� #� +� +�C�� 5� 5� =� =�c�3� G� G�Gr- rV � list[str]c � � t | � � dk rdS t j d| d � � }|sdS |� d� � }d|v S )z� Determine if the ABI corresponds to a threaded (`--disable-gil`) build. The threaded builds are indicated by a "t" in the abiflags. r Fz cp\d+(.*)r �t)�len�re�match�group)rV �m�abiflagss r+ �_is_threaded_cpythonrs } sS � � �4�y�y�A�~�~��u� �� �t�A�w�'�'�A� � ��u��w�w�q�z�z�H� �(�?�r- �python_version� PythonVersion� threadingc �T � t | � � dk ot | � � dk o| S )z� Determine if the Python version supports abi3. PEP 384 was first implemented in Python 3.2. The threaded (`--disable-gil`) builds do not support abi3. r )� � )rm �tuple)rt rv s r+ � _abi3_appliesr{ � s0 � � �~� � �� "� X�u�^�'<�'<��'F� X�y�=�Xr- � py_versionc � � t | � � } g }t | d d� � � }dx}x}x}}t d|� � }t t d� � } dt v } |s|�| s| rd}| dk rt d|� � rd }| d k rGt d |� � } | s| �d }| d k r*t d|� � } | dk s| �t j dk rd}n |r|� d|� |� �� � |� dd|� |� |� |� |� �� � |S )Nry � �Py_DEBUG�gettotalrefcountz_d.pyd�d)rx � �Py_GIL_DISABLEDrl )rx � � WITH_PYMALLOCrq )rx rx �Py_UNICODE_SIZEr i�� �ur r ) rz �_version_nodotrc �hasattr�sysr � maxunicode�append�insert) r| r[ rV �versionrv ra �pymalloc�ucs4� with_debug� has_refcount�has_ext� with_pymalloc� unicode_sizes r+ � _cpython_abisr� � so � ��z�"�"�J� �D� �Z����^�,�,�G�*,�,�I�,��,��4� ��T�2�2�J��3� 2�3�3�L� �,�,�G�� �j�(�l�(�g�(����W� � � �1B�D�!I�!I� �� ��F���'���>�>� � � �M� 1��H� �� � �*�+<�d�C�C�L��q� � � �$�� �8�)C�)C���� � /� � � �-��-�)�-�-�.�.�.��K�K��C��C��C�E�C�8�C�T�C�C�D�D�D� �Kr- �r[ �PythonVersion | None�Iterable[str] | NonerW � Iterator[Tag]c # � � K � | st j dd� } dt | dd� � � � �� |�&t | � � dk rt | |� � }ng }t |� � }dD ](} |� |� � �# t $ r Y �%w xY wt |p t � � � � }|D ]}|D ]}t � ||� � V � ��t |� � }t | |� � }|r� fd�|D � � E d{V �� � fd�|D � � E d{V �� |r`t | d dz dd� � D ]G} |D ]@}d � t | d | f� � � � � � t � d |� � V � �A�FdS dS ) a Yields the tags for a CPython interpreter. The tags consist of: - cp<python_version>-<abi>-<platform> - cp<python_version>-abi3-<platform> - cp<python_version>-none-<platform> - cp<less than python_version>-abi3-<platform> # Older Python versions down to 3.2. If python_version only specifies a major version then user-provided ABIs and the 'none' ABItag will be used. If 'abi3' or 'none' are specified in 'abis' then they will be yielded at their normal position and not at the beginning. Nry r r )�abi3�nonec 3 �: �K � | ]}t �d |� � V � �dS )r� N�r ��.0rX r s �r+ � <genexpr>z cpython_tags.<locals>.<genexpr>� s/ �� � � �S�S�I�C� �V�Y�7�7�S�S�S�S�S�Sr- c 3 �: �K � | ]}t �d |� � V � �dS )r� Nr� r� s �r+ r� z cpython_tags.<locals>.<genexpr>� s/ �� � � �O�O� ��K���3�3�O�O�O�O�O�Or- ���z cp{version}r �r� r� )r� � version_infor� rm r� �list�remove� ValueError� platform_tagsr rs r{ �range�format) rt rV rW r[ � explicit_abir" rX rv �use_abi3� minor_versionr s @r+ � cpython_tagsr� � s8 �� � � �, � .� �)�"�1�"�-��;�~�n�R�a�R�&8�9�9�;�;�K� �|� �~� � �� "� "� � ��6�6�D�D��D� ��:�:�D�(� � � � � �K�K� � %� %� %� %��� � � � �D� ���� �Y�1�-�/�/�2�2�I�� 3� 3��"� 3� 3�I��k�3� �2�2� 2� 2� 2� 2� 3� %�T�*�*�I� �^�Y�7�7�H�� T�S�S�S�S��S�S�S�S�S�S�S�S�S�S�O�O�O�O�Y�O�O�O�O�O�O�O�O�O�O�� :� "�>�!�#4�q�#8�!�R� @� @� :� :�M� &� :� :� � +� 2� 2� *�N�1�,=�}�+M� N� N� 3� � � � �+�v�y�9�9�9�9�9�9� :�:� :� :� :s �0B� B�Bc �6 � t dd�� � } t | t � � r | d dk rt d� � �| � d� � }t |� � dk r!t t j dd � � � S |d }|� d � � r d |� d � � d z }n�|� d � � r |� d � � d }n�|� d� � r1d � |� d � � dd � � � }nM|� d� � r1d � |� d � � dd� � � }n|r|}ng S t |� � gS )z1 Return the ABI tag based on EXT_SUFFIX. � EXT_SUFFIXTr� r rO z.invalid sysconfig.get_config_var('EXT_SUFFIX')rx Nry r r r r= r �graalpy) rc r6 r! � SystemErrorrQ rm r� r� r� � startswith�joinri )� ext_suffix�parts�soabir" s r+ � _generic_abir� � s� � � !� �D�9�9�9�J� �j�#� &� &� L�*�Q�-�3�*>�*>��J�K�K�K� � � �S� !� !�E� �5�z�z�A�~�~� �S� -�b�q�b� 1�2�2�2� �!�H�E� ��� �"�"� ��U�[�[��%�%�a�(�(��� � � �$� � � ��k�k�#� � �q�!��� � � �&� !� !� ��h�h�u�{�{�3�'�'����+�,�,��� � � �)� $� $� ��h�h�u�{�{�3�'�'����+�,�,��� � ����� � �c� "� "� #�#r- r � str | Nonec # �^ K � | s5t � � }t |�� � }d� ||g� � } |�t � � }nt |� � }t |p t � � � � }d|vr|� d� � |D ]}|D ]}t | ||� � V � ��dS )z� Yields the tags for a generic interpreter. The tags consist of: - <interpreter>-<abi>-<platform> The "none" ABI will be added if it was not explicitly provided. r� r~ Nr� )�interpreter_name�interpreter_versionr� r� r� r� r� r )r rV rW r[ � interp_name�interp_versionr" rX s r+ � generic_tagsr� s� � � � � � =�&�(�(� �,�$�7�7�7���g�g�{�N� ;�<�<� � �|��~�~����D�z�z���Y�1�-�/�/�2�2�I� �T��� � � �F����� 3� 3��"� 3� 3�I��k�3� �2�2� 2� 2� 2� 2� 3�3� 3r- � Iterator[str]c # � K � t | � � dk r dt | dd� � � � �V � d| d � �V � t | � � dk r9t | d dz dd� � D ] }dt | d |f� � � �V � � dS dS )z� Yields Python versions in descending order. After the latest version, the major-only version will be yielded, and then all previous versions of that major version. r r Nry r r� )rm r� r� )r| �minors r+ �_py_interpreter_ranger� < s� � � � � �:������3�>�*�R�a�R�.�1�1�3�3�3�3�3� �z�!�}� � � � � � �:�������:�a�=�1�,�b�"�5�5� @� @�E�?�~�z�!�}�e�&<�=�=�?�?� ?� ?� ?� ?� �� @� @r- c # �8 K � | st j dd� } t |p t � � � � }t | � � D ]}|D ]}t |d|� � V � ��|rt |dd� � V � t | � � D ]}t |dd� � V � �dS )z� Yields the sequence of tags that are compatible with a specific version of Python. The tags consist of: - py*-none-<platform> - <interpreter>-none-any # ... if `interpreter` is provided. - py*-none-any Nry r� �any)r� r� r� r� r� r )rt r rW r� rX s r+ �compatible_tagsr� K s� � � � � � .� �)�"�1�"�-���Y�1�-�/�/�2�2�I�(� �8�8� 2� 2��"� 2� 2�I��g�v�y�1�1� 1� 1� 1� 1� 2�� .��+�v�u�-�-�-�-�-�(� �8�8� *� *���'�6�5�)�)�)�)�)�)�*� *r- �arch�is_32bitc �< � |s| S | � d� � rdS dS )N�ppc�i386)r� )r� r� s r+ � _mac_archr� d s- � � � �� � ���u� � � ��u� �6r- r� � AppleVersion�cpu_archc � � |g}|dk r | dk rg S |� g d�� � nu|dk r | dk rg S |� g d�� � nO|dk r$| dk s| dk rg S |� d� � n%|d k r | d k rg S |� d d g� � |d v r|� d� � |dv r|� d� � |S )N�x86_64)� r )�intel�fat64�fat32r� )r� r� �fat�ppc64)r� � r� r� )r� � r� r� > �arm64r� � universal2> r� r� r� r� r� � universal)�extendr� )r� r� �formatss r+ �_mac_binary_formatsr� n s$ � ��j�G��8��� �W� � ��I����2�2�2�3�3�3�3� �V� � � �W� � ��I����0�0�0�1�1�1�1� �W� � � �W� � ��'� 1� 1��I����w� � � � � �U� � � �W� � ��I������'�(�(�(��&�&�&����|�$�$�$��>�>�>����{�#�#�#� �Nr- �AppleVersion | Nonec # � K � t j � � \ }}}| ��t dt t t |� d� � dd� � � � � � � } | dk r�t j t j dddgd d d it j d � � � j }t dt t t |� d� � dd� � � � � � � } n| } |�t |� � }n|}d | k rS| dk rMt | d dd� � D ]5}d|f}t ||� � }|D ] }d� d||�� � V � � �6| dk rMt | d dd� � D ]5} | df}t ||� � }|D ] }d� | d|�� � V � � �6| dk r�|dk rUt ddd� � D ]A}d|f}t ||� � }|D ](}d� |d |d |�� � V � �)�BdS t ddd� � D ]0}d|f}d}d� |d |d |�� � V � �/dS dS )aD Yields the platform tags for a macOS system. The `version` parameter is a two-item tuple specifying the macOS version to generate platform tags for. The `arch` parameter is the CPU architecture to generate platform tags for. Both parameters default to the appropriate value for the current system. Nr� rO ry )r� � z-sSz-cz-import platform; print(platform.mac_ver()[0])T�SYSTEM_VERSION_COMPAT�0)�check�env�stdout�text)r� r )� r r r� r� z&macosx_{major}_{minor}_{binary_format})�majorr� � binary_formatr r� r� rx r� )r# �mac_verr rz �mapr9 rQ � subprocess�runr� � executable�PIPEr� r� r� r� r� ) r� r� � version_strrf r� r� �compat_version�binary_formatsr� � major_versions r+ � mac_platformsr� � sY � � � � (� /� 1� 1� �K��H����~�u�S��k�6G�6G��6L�6L�R�a�R�6P�-Q�-Q�'R�'R�S�S�� �h� � � %�.��N���C� � �,�c�2�!��� � � � � � �>�5��S�+�:K�:K�C�:P�:P�QS�RS�QS�:T�1U�1U�+V�+V�W�W�G���� �|���"�"������'���g�� /� /� #�7�1�:�r�2� 6� 6� � �M� � � .�N� 0� �� F� F�N�!/� � � �>�E�E� �M� � F� � � � � � � � �'��� #�7�1�:�r�2� 6� 6� � �M� *�A� -�N� 0� �� F� F�N�!/� � � �>�E�E�'�q� � F� � � � � � � � �'��� �8� � �!&�r�1�b�!1�!1� � � �!#�]�!2��!4�^�T�!J�!J��%3� � �M�B�I�I� ,�Q� /� ,�Q� /�&3� J� � � � � � �� � � "'�r�1�b�!1�!1� � � �!#�]�!2�� ,� �>�E�E�(��+�(��+�"/� F� � � � � � �- ��& � r- � multiarchc # � K � | �ct j � � \ }}}}t dt t t |� d� � dd� � � � � � � } |�t j j }|� dd� � }d}| d d k rdS |� | d | d |� � � V � t | d d z d d � � D ]"}|� | d ||� � � V � �#t | d d z d d � � D ]0}t dd d � � D ] }|� |||� � � V � � �1dS )a� Yields the platform tags for an iOS system. :param version: A two-item tuple specifying the iOS version to generate platform tags for. Defaults to the current iOS version. :param multiarch: The CPU architecture+ABI to generate platform tags for - (the value used by `sys.implementation._multiarch` e.g., `arm64_iphoneos` or `x84_64_iphonesimulator`). Defaults to the current multiarch value. Nr� rO ry r= rf z ios_{major}_{minor}_{multiarch}r � r )r� r� r� r� r� � ) r# �ios_verr rz r� r9 rQ r� �implementation� _multiarchrh r� r� )r� r� rf �release�ios_platform_templater� r� s r+ � ios_platformsr � s� � � � � �� $�+�-�-���7�A�q��~�u�S��g�m�m�C�6H�6H��!��6L�-M�-M�'N�'N�O�O�����&�1� ��!�!�#�s�+�+�I� =�� �q�z�B����� � &� &��a�j��� �i� '� � � � � � �w�q�z�A�~�r�2�.�.� � ��#�*�*��!�*�E�Y� +� � � � � � � �w�q�z�A�~�r�2�.�.� � ���1�b�"�%�%� � �E�'�.�.��5�I� /� � � � � � � �� r- c # � K � t t j � � � � }|� d� � s|V � d S | r|dk rd}n|dk rd}|� dd� � \ }}ddd gi� ||g� � }t j |� � E d {V �� t j |� � E d {V �� |D ] }d|� �V � � d S ) N�linux_� linux_x86_64� linux_i686� linux_aarch64� linux_armv8lrf r �armv8l�armv7l) ri r^ � get_platformr� rQ �getr r� r )r� �linuxrf r� �archss r+ �_linux_platformsr s � � � � �i� 4� 6� 6� 7� 7�E� � � �H� %� %� �� � � ���� #� �N� "� "� �E�E� �o� %� %�"�E��k�k�#�q�!�!�G�A�t� ��(�+� ,� 0� 0���v� >� >�E��'��.�.�.�.�.�.�.�.�.��'��.�.�.�.�.�.�.�.�.�� � �� �t�o�o� � � � � � r- c # �N K � t t j � � � � V � d S r' )ri r^ r rK r- r+ �_generic_platformsr 2 s) � � � � �I� 2� 4� 4� 5� 5�5�5�5�5�5r- c � � t j � � dk rt � � S t j � � dk rt � � S t j � � dk rt � � S t � � S )z; Provides the platform tags for this installation. �Darwin�iOS�Linux)r# �systemr� r r r rK r- r+ r� r� 6 si � � ����H�$�$� ��� � � � � �e� #� #� ��� � � � � �g� %� %� �!�!�!�!�#�#�#r- c �\ � t j j } t � | � � p| S )z� Returns the name of the running interpreter. Some implementations have a reserved, two-letter abbreviation which will be returned when appropriate. )r� r� rZ r r )rZ s r+ r� r� D s( � � � � "�D� "� &� &�t� ,� ,� 4��4r- c � � t d| �� � }|rt |� � }n!t t j dd� � � }|S )z9 Returns the version of the running interpreter. �py_version_nodotr� Nry )rc r! r� r� r� )r[ r� s r+ r� r� O sJ � � � 0�t�<�<�<�G�� 7��g�,�,��� ��!1�"�1�"�!5�6�6�� �Nr- c �R � d� t t | � � � � S )Nr~ )r� r� r! r� s r+ r� r� [ s � � �7�7�3�s�G�$�$� %� %�%r- c # � K � t � � }|dk rt | �� � E d{V �� nt � � E d{V �� |dk rd}n |dk rdt | �� � z }nd}t |�� � E d{V �� dS )z� Returns the sequence of tag triples for the running interpreter. The order of the sequence corresponds to priority order for the interpreter, from most to least important. r r� Nr �pp3)r )r� r� r� r� r� )r[ r� �interps r+ �sys_tagsr _ s� � � � � #�$�$�K��d��� �T�*�*�*�*�*�*�*�*�*�*�*� �>�>�!�!�!�!�!�!�!��d������ �� � ��+��6�6�6�6����� �6�2�2�2�2�2�2�2�2�2�2�2�2r- )rL r! r$ rM )F)rZ r! r[ r4 r$ r\ )rd r! r$ r! )rV rj r$ r4 )rt ru rv r4 r$ r4 )r| ru r[ r4 r$ rj )NNN) rt r� rV r� rW r� r[ r4 r$ r� )r$ rj ) r r� rV r� rW r� r[ r4 r$ r� )r| ru r$ r� )rt r� r r� rW r� r$ r� )r� r! r� r4 r$ r! )r� r� r� r! r$ rj )NN)r� r� r� r� r$ r� )r� r� r� r� r$ r� )r� r4 r$ r� )r$ r� rD )r[ r4 r$ r! )r� ru r$ r! )r[ r4 r$ r� )5� __future__r �loggingr# rn �structr� r� r^ �importlib.machineryr �typingr r r r r r~ r r � getLoggerrE r` r9 ru r� r �__annotations__�calcsize�_32_BIT_INTERPRETERr rY rc ri rs r{ r� r� r� r� r� r� r� r� r� r r r r� r� r� r� r rK r- r+ �<module>r' s� �� #� "� "� "� "� "� "� ���� ���� � � � � � � � � � � � � � � � � � � � � 2� 2� 2� 2� 2� 2�� � � � � � � � � � � � � � %� $� $� $� $� $� $� $� �� �8� $� $���� � ��S�#�X�� � �� ��� +� +� � � � � � &�f�o�c�*�*�a�/� �3(� 3(� 3(� 3(� 3(� 3(� 3(� 3(�l � � � � � � � � �H� H� H� H� � � � � Y� Y� Y� Y� � � � � �D ,0�!%�&*�9:� � 9:� 9:� 9:� 9:� 9:� 9:�x&$� &$� &$� &$�T #�!%�&*� 3� � 3� 3� 3� 3� 3� 3�> @� @� @� @� ,0� "�&*�*� *� *� *� *�2 +>� � � � � � � � � �B =A�U� U� U� U� U�r BF�6� 6� 6� 6� 6�r ':� � � � � �&6� 6� 6� 6� $� $� $� $� 5� 5� 5� 5� ).� � � � � � �&� &� &� &� #� 3� 3� 3� 3� 3� 3� 3� 3r- __pycache__/utils.cpython-311.pyc 0000644 00000020214 15004414131 0012606 0 ustar 00 � ]�bg� � � � d dl mZ d dlZd dlmZmZmZmZ ddlm Z m Z ddl m Z m Z eed eeef f Z ede� � Z G d � d e� � Z G d � d e� � Z G d � de� � Z ej dej � � Z ej d� � Z ej d� � Z ej d� � Zdd�d'd�Z d(d�Z d d �d)d!�Z d*d$�Z d+d&�Z dS ),� )� annotationsN)�NewType�Tuple�Union�cast� )�Tag� parse_tag)�InvalidVersion�Version� �NormalizedNamec � � e Zd ZdZdS )� InvalidNamezW An invalid distribution name; users should refer to the packaging user guide. N��__name__� __module__� __qualname__�__doc__r � �l/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/utils.pyr r � � � � � � �� � � r r c � � e Zd ZdZdS )�InvalidWheelFilenamezM An invalid wheel filename was found, users should refer to PEP 427. Nr r r r r r r r r c � � e Zd ZdZdS )�InvalidSdistFilenamez^ An invalid sdist filename was found, users should refer to the packaging user guide. Nr r r r r r r r r z)^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$z[-_.]+z/^([a-z0-9]|[a-z0-9]([a-z0-9-](?!--))*[a-z0-9])$z (\d+)(.*)F)�validate�name�strr �bool�returnc �� � |r,t � | � � st d| ��� � �t � d| � � � � � }t t |� � S )Nzname is invalid: �-)�_validate_regex�matchr �_canonicalize_regex�sub�lowerr r )r r �values r �canonicalize_namer* - sg � �� 8��-�-�d�3�3� 8��6�d�6�6�7�7�7� � #� #�C�� .� .� 4� 4� 6� 6�E� ��� &� &�&r c �: � t � | � � d uS �N)�_normalized_regexr% )r s r �is_normalized_namer. 5 s � � � "� "�4� (� (�� 4�4r T)�strip_trailing_zero�version� Version | strr/ c �� � t | t � � r# t | � � }n# t $ r | cY S w xY w| }g }|j dk r |� |j � d�� � d� d� |j D � � � � }|rt j dd|� � }|� |� � |j �7|� d� d� |j D � � � � � � |j � |� d |j � �� � |j � |� d |j � �� � |j � |� d |j � �� � d� |� � S ) z� This is very similar to Version.__str__, but has one subtle difference with the way it handles the release segment. r �!�.c 3 �4 K � | ]}t |� � V � �d S r, �r ��.0�xs r � <genexpr>z'canonicalize_version.<locals>.<genexpr>P s( � � � � >� >�!�s�1�v�v� >� >� >� >� >� >r z(\.0)+$� Nc 3 �4 K � | ]}t |� � V � �d S r, r6 r7 s r r: z'canonicalize_version.<locals>.<genexpr>X s( � � � � 8� 8��S��V�V� 8� 8� 8� 8� 8� 8r z.postz.dev�+)� isinstancer r r �epoch�append�join�release�rer' �pre�post�dev�local)r0 r/ �parsed�parts�release_segments r �canonicalize_versionrK 9 s� � � �'�3� � � � � �W�%�%�F�F�� � � � ��N�N�N� ���� �� �E� �|�q��� � � �� �'�'�'�(�(�(� �h�h� >� >�v�~� >� >� >�>�>�O�� B� �&��R� �A�A�� �L�L� �!�!�!� �z� � � � �R�W�W� 8� 8�V�Z� 8� 8� 8�8�8�9�9�9� �{� � � � �*�V�[�*�*�+�+�+� �z� � � � �(�F�J�(�(�)�)�)� �|� � � � �'�� �'�'�(�(�(� �7�7�5�>�>�s �' � 6�6�filename�8tuple[NormalizedName, Version, BuildTag, frozenset[Tag]]c �N � | � d� � st d| � �� � �| d d� } | � d� � }|dvrt d| � �� � �| � d|dz � � }|d }d |v s t j d |t j � � �t d | � �� � �t |� � } t |d � � }n%# t $ r}t d | � �� � |�d }~ww xY w|dk r�|d }t � |� � }|�t d|� d| � d�� � �t t t |� d � � � � |� d� � f� � } nd} t |d � � } ||| | fS )Nz.whlz3Invalid wheel filename (extension must be '.whl'): ���r# )� � z0Invalid wheel filename (wrong number of parts): � r �__z ^[\w\d._]*$zInvalid project name: r z*Invalid wheel filename (invalid version): rQ zInvalid build number: z in '�'r ���)�endswithr �count�splitrC r% �UNICODEr* r r �_build_tag_regexr �BuildTag�int�groupr ) rL �dashesrI � name_partr r0 �e� build_part� build_match�build�tagss r �parse_wheel_filenamere i s� � � � � �V� $� $� �"� L�(� L� L� � � � ����}�H� �^�^�C� � �F� �V���"� I�x� I� I� � � � �N�N�3��� � +� +�E��a��I� �y���B�H�^�Y�� � K� K� S�"�#F�H�#F�#F�G�G�G� �Y� '� '�D���%��(�#�#���� � � � �"� C�� C� C� � �� ��������� ��{�{��1�X� �&�,�,�Z�8�8� � � �&�E��E�E�(�E�E�E�� � � �X��K�$5�$5�a�$8�$8� 9� 9�;�;L�;L�Q�;O�;O� P�Q�Q����� �U�2�Y� � �D� �'�5�$� '�'s �C � C<�$C7�7C<� tuple[NormalizedName, Version]c �� � | � d� � r| d t d� � � }n@| � d� � r| d t d� � � }nt d| � �� � �|� d� � \ }}}|st d| � �� � �t |� � } t |� � }n%# t $ r}t d| � �� � |�d }~ww xY w||fS )Nz.tar.gzz.zipz@Invalid sdist filename (extension must be '.tar.gz' or '.zip'): r# zInvalid sdist filename: z*Invalid sdist filename (invalid version): )rV �lenr � rpartitionr* r r )rL � file_stemr_ �sep� version_partr r0 r` s r �parse_sdist_filenamerm � s, � �����#�#� � � .��I���� .�/� � � � � �6� "� "� � �^��F� � �|�^�,� � �"� �� � � � � � $-�#7�#7��#<�#<� �I�s�L� � J�"�#H�h�#H�#H�I�I�I� �Y� '� '�D���,�'�'���� � � � �"� C�� C� C� � �� ��������� �'�?�s �,B< �< C �C�C )r r r r r! r )r r r! r )r0 r1 r/ r r! r )rL r r! rM )rL r r! rf )!� __future__r rC �typingr r r r rd r r r0 r r r\ r r[ r � ValueErrorr r r �compile� IGNORECASEr$ r& r- rZ r* r. rK re rm r r r �<module>rs s �� #� "� "� "� "� "� � � � � .� .� .� .� .� .� .� .� .� .� .� .� � � � � � � � � ,� ,� ,� ,� ,� ,� ,� ,� ��r��E�#�s�(�O�+� ,����)�3�/�/��� � � � �*� � � � � � � � �:� � � � � � � � �:� � � � �"�*�0�"�-�� �� !�b�j��+�+� � �B�J� Q�R�R� � �2�:�l�+�+� � 6;� '� '� '� '� '� '�5� 5� 5� 5� <@�-� -� -� -� -� -�`((� ((� ((� ((�V� � � � � r __pycache__/version.cpython-311.pyc 0000644 00000050562 15004414131 0013144 0 ustar 00 � ]�bgR? � � � d Z ddlmZ ddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZmZmZ g d�Ze e eef df Ze eee eef f Ze ee e e eef e ee eef f f df f Ze ee edf eeeef Zeeegef Z G d � d e� � Zd)d�Z G d� de � � Z G d� d� � Z dZ e Z G d� de � � Z!d*d�Z" ej# d � � Z$d+d �Z%d,d(�Z&dS )-zN .. testsetup:: from pip._vendor.packaging.version import parse, Version � )� annotationsN)�Any�Callable� NamedTuple� SupportsInt�Tuple�Union� )�Infinity� InfinityType�NegativeInfinity�NegativeInfinityType)�VERSION_PATTERN�parse�Version�InvalidVersion.c �L � e Zd ZU ded< ded< ded< ded< ded< d ed < d S ) �_Version�int�epoch�tuple[int, ...]�release�tuple[str, int] | None�dev�pre�post�LocalType | None�localN)�__name__� __module__� __qualname__�__annotations__� � �n/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/version.pyr r & sW � � � � � � ��J�J�J� � � � � � � � � � � � � � � � ������r$ r �version�str�returnr c � � t | � � S )z�Parse the given version string. >>> parse('1.0.dev1') <Version('1.0.dev1')> :param version: The version string to parse. :raises InvalidVersion: When the version string is not a valid version. )r )r& s r% r r / s � � �7� � �r$ c � � e Zd ZdZdS )r z�Raised when a version string is not a valid version. >>> Version("invalid") Traceback (most recent call last): ... packaging.version.InvalidVersion: Invalid version: 'invalid' N)r r r! �__doc__r# r$ r% r r ; s � � � � � �� � � r$ r c �R � e Zd ZU ded< dd�Zdd�Zdd �Zdd �Zdd �Zdd �Z dd�Z dS )� _BaseVersionztuple[Any, ...]�_keyr( r c �* � t | j � � S �N)�hashr. ��selfs r% �__hash__z_BaseVersion.__hash__H s � ��D�I��� r$ �other�boolc �Z � t |t � � st S | j |j k S r0 �� isinstancer- �NotImplementedr. �r3 r5 s r% �__lt__z_BaseVersion.__lt__N �) � ��%� �.�.� "�!� !��y�5�:�%�%r$ c �Z � t |t � � st S | j |j k S r0 r8 r; s r% �__le__z_BaseVersion.__le__T �) � ��%� �.�.� "�!� !��y�E�J�&�&r$ �objectc �Z � t |t � � st S | j |j k S r0 r8 r; s r% �__eq__z_BaseVersion.__eq__Z r@ r$ c �Z � t |t � � st S | j |j k S r0 r8 r; s r% �__ge__z_BaseVersion.__ge__` r@ r$ c �Z � t |t � � st S | j |j k S r0 r8 r; s r% �__gt__z_BaseVersion.__gt__f r= r$ c �Z � t |t � � st S | j |j k S r0 r8 r; s r% �__ne__z_BaseVersion.__ne__l r@ r$ N�r( r )r5 r- r( r6 )r5 rA r( r6 ) r r r! r" r4 r< r? rC rE rG rI r# r$ r% r- r- E s� � � � � � � ����� � � � � &� &� &� &� '� '� '� '� '� '� '� '� '� '� '� '� &� &� &� &� '� '� '� '� '� 'r$ r- a� v? (?: (?:(?P<epoch>[0-9]+)!)? # epoch (?P<release>[0-9]+(?:\.[0-9]+)*) # release segment (?P<pre> # pre-release [-_\.]? (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc) [-_\.]? (?P<pre_n>[0-9]+)? )? (?P<post> # post release (?:-(?P<post_n1>[0-9]+)) | (?: [-_\.]? (?P<post_l>post|rev|r) [-_\.]? (?P<post_n2>[0-9]+)? ) )? (?P<dev> # dev release [-_\.]? (?P<dev_l>dev) [-_\.]? (?P<dev_n>[0-9]+)? )? ) (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version c �� � e Zd ZU dZ ej dez dz ej ej z � � Z de d< d"d �Z d#d �Z d#d �Z ed$d�� � Zed%d�� � Zed&d�� � Zed'd�� � Zed'd�� � Zed(d�� � Zed#d�� � Zed#d�� � Zed)d�� � Zed)d �� � Zed)d �� � Zed$d �� � Zed$d �� � Zed$d �� � Z d!S )*r a� This class abstracts handling of a project's versions. A :class:`Version` instance is comparison aware and can be compared and sorted using the standard Python interfaces. >>> v1 = Version("1.0a5") >>> v2 = Version("1.0") >>> v1 <Version('1.0a5')> >>> v2 <Version('1.0')> >>> v1 < v2 True >>> v1 == v2 False >>> v1 > v2 False >>> v1 >= v2 False >>> v1 <= v2 True z^\s*z\s*$�CmpKeyr. r& r' r( �Nonec �� � | j � |� � }|st d|� d�� � �t |� d� � r"t |� d� � � � ndt d� |� d� � � d� � D � � � � t |� d� � |� d � � � � t |� d � � |� d � � p|� d � � � � t |� d � � |� d� � � � t |� d� � � � �� � | _ t | j j | j j | j j | j j | j j | j j � � | _ dS )aC Initialize a Version object. :param version: The string representation of a version which will be parsed and normalized before use. :raises InvalidVersion: If the ``version`` does not conform to PEP 440 in any way then this exception will be raised. zInvalid version: '�'r r c 3 �4 K � | ]}t |� � V � �d S r0 )r ��.0�is r% � <genexpr>z#Version.__init__.<locals>.<genexpr>� s( � � � �L�L�Q�#�a�&�&�L�L�L�L�L�Lr$ r �.�pre_l�pre_n�post_l�post_n1�post_n2�dev_l�dev_nr )r r r r r r N)�_regex�searchr r �groupr �tuple�split�_parse_letter_version�_parse_local_version�_version�_cmpkeyr r r r r r r. )r3 r& �matchs r% �__init__zVersion.__init__� s� � � � �"�"�7�+�+��� B� �!@�g�!@�!@�!@�A�A� A� !�/4�{�{�7�/C�/C�J�#�e�k�k�'�*�*�+�+�+���L�L�%�+�+�i�*@�*@�*F�*F�s�*K�*K�L�L�L�L�L�%�e�k�k�'�&:�&:�E�K�K��<P�<P�Q�Q�&�� � �H�%�%�u�{�{�9�'=�'=�'W����Y�AW�AW�� � &�e�k�k�'�&:�&:�E�K�K��<P�<P�Q�Q�&�u�{�{�7�';�';�<�<� � � �� � � �M� � �M� !� �M� � �M� � �M� � �M� � � �� � � r$ c � � d| � d�S )z�A representation of the Version that shows all internal state. >>> Version('1.0.0') <Version('1.0.0')> z <Version('z')>r# r2 s r% �__repr__zVersion.__repr__� s � � &�D�%�%�%�%r$ c �B � g }| j dk r |� | j � d�� � |� d� d� | j D � � � � � � | j �7|� d� d� | j D � � � � � � | j � |� d| j � �� � | j � |� d | j � �� � | j � |� d | j � �� � d� |� � S ) zA string representation of the version that can be rounded-tripped. >>> str(Version("1.0a5")) '1.0a5' r �!rU c 3 �4 K � | ]}t |� � V � �d S r0 �r' �rR �xs r% rT z"Version.__str__.<locals>.<genexpr>� �( � � � � ;� ;��c�!�f�f� ;� ;� ;� ;� ;� ;r$ N� c 3 �4 K � | ]}t |� � V � �d S r0 rm rn s r% rT z"Version.__str__.<locals>.<genexpr>� s( � � � � :� :�A��Q��� :� :� :� :� :� :r$ z.postz.dev�+)r �append�joinr r r r r �r3 �partss r% �__str__zVersion.__str__� s" � � �� �:��?�?� �L�L�D�J�)�)�)� *� *� *� � � �S�X�X� ;� ;�d�l� ;� ;� ;�;�;�<�<�<� �8� � �L�L���� :� :��� :� :� :�:�:� ;� ;� ;� �9� � �L�L�,���,�,� -� -� -� �8� � �L�L�*���*�*� +� +� +� �:� !� �L�L�)�T�Z�)�)� *� *� *��w�w�u�~�~� r$ r c � � | j j S )zThe epoch of the version. >>> Version("2.0.0").epoch 0 >>> Version("1!2.0.0").epoch 1 )rd r r2 s r% r z Version.epoch s � � �}�"�"r$ r c � � | j j S )ad The components of the "release" segment of the version. >>> Version("1.2.3").release (1, 2, 3) >>> Version("2.0.0").release (2, 0, 0) >>> Version("1!2.0.0.post0").release (2, 0, 0) Includes trailing zeroes but not the epoch or any pre-release / development / post-release suffixes. )rd r r2 s r% r zVersion.release s � � �}�$�$r$ r c � � | j j S )a The pre-release segment of the version. >>> print(Version("1.2.3").pre) None >>> Version("1.2.3a1").pre ('a', 1) >>> Version("1.2.3b1").pre ('b', 1) >>> Version("1.2.3rc1").pre ('rc', 1) )rd r r2 s r% r z Version.pre& s � � �}� � r$ � int | Nonec �B � | j j r| j j d ndS )z�The post-release number of the version. >>> print(Version("1.2.3").post) None >>> Version("1.2.3.post1").post 1 r N)rd r r2 s r% r z Version.post5 s# � � )-� �(:�D�t�}�!�!�$�$��Dr$ c �B � | j j r| j j d ndS )z�The development number of the version. >>> print(Version("1.2.3").dev) None >>> Version("1.2.3.dev1").dev 1 r N)rd r r2 s r% r z Version.dev@ s# � � (,�}�'8�B�t�}� ��#�#�d�Br$ � str | Nonec �p � | j j r)d� d� | j j D � � � � S dS )z�The local version segment of the version. >>> print(Version("1.2.3").local) None >>> Version("1.2.3+abc").local 'abc' rU c 3 �4 K � | ]}t |� � V � �d S r0 rm rn s r% rT z Version.local.<locals>.<genexpr>U s( � � � �@�@�q�C��F�F�@�@�@�@�@�@r$ N)rd r ru r2 s r% r z Version.localK s< � � �=� � ��8�8�@�@�D�M�,?�@�@�@�@�@� @��4r$ c �T � t | � � � dd� � d S )z�The public portion of the version. >>> Version("1.2.3").public '1.2.3' >>> Version("1.2.3+abc").public '1.2.3' >>> Version("1.2.3+abc.dev1").public '1.2.3' rs r r )r' ra r2 s r% �publiczVersion.publicY s# � � �4�y�y���s�A�&�&�q�)�)r$ c �� � g }| j dk r |� | j � d�� � |� d� d� | j D � � � � � � d� |� � S )a] The "base version" of the version. >>> Version("1.2.3").base_version '1.2.3' >>> Version("1.2.3+abc").base_version '1.2.3' >>> Version("1!1.2.3+abc.dev1").base_version '1!1.2.3' The "base version" is the public version of the project without any pre or post release markers. r rk rU c 3 �4 K � | ]}t |� � V � �d S r0 rm rn s r% rT z'Version.base_version.<locals>.<genexpr>{ rp r$ rq )r rt ru r rv s r% � base_versionzVersion.base_versionf st � � �� �:��?�?� �L�L�D�J�)�)�)� *� *� *� � � �S�X�X� ;� ;�d�l� ;� ;� ;�;�;�<�<�<��w�w�u�~�~� r$ r6 c �& � | j dup| j duS )aT Whether this version is a pre-release. >>> Version("1.2.3").is_prerelease False >>> Version("1.2.3a1").is_prerelease True >>> Version("1.2.3b1").is_prerelease True >>> Version("1.2.3rc1").is_prerelease True >>> Version("1.2.3dev1").is_prerelease True N)r r r2 s r% � is_prereleasezVersion.is_prerelease s � � �x�t�#�;�t�x�t�';�;r$ c � � | j duS )z�Whether this version is a post-release. >>> Version("1.2.3").is_postrelease False >>> Version("1.2.3.post1").is_postrelease True N)r r2 s r% �is_postreleasezVersion.is_postrelease� s � � �y��$�$r$ c � � | j duS )z�Whether this version is a development release. >>> Version("1.2.3").is_devrelease False >>> Version("1.2.3.dev1").is_devrelease True N)r r2 s r% � is_devreleasezVersion.is_devrelease� s � � �x�t�#�#r$ c �P � t | j � � dk r | j d ndS )zqThe first item of :attr:`release` or ``0`` if unavailable. >>> Version("1.2.3").major 1 r r ��lenr r2 s r% �majorz Version.major� s( � � #&�d�l�"3�"3�q�"8�"8�t�|�A���a�?r$ c �P � t | j � � dk r | j d ndS )z�The second item of :attr:`release` or ``0`` if unavailable. >>> Version("1.2.3").minor 2 >>> Version("1").minor 0 � r r r� r2 s r% �minorz Version.minor� �( � � #&�d�l�"3�"3�q�"8�"8�t�|�A���a�?r$ c �P � t | j � � dk r | j d ndS )z�The third item of :attr:`release` or ``0`` if unavailable. >>> Version("1.2.3").micro 3 >>> Version("1").micro 0 � r� r r� r2 s r% �microz Version.micro� r� r$ N)r& r' r( rM )r( r' rJ )r( r )r( r )r( r| )r( r )r( r6 ) r r r! r+ �re�compiler �VERBOSE� IGNORECASEr] r" rg ri rx �propertyr r r r r r r� r� r� r� r� r� r� r� r# r$ r% r r � se � � � � � � �� �. �R�Z��/�1�G�;�R�Z�"�-�=W� X� X�F��L�L�L�$ � $ � $ � $ �L&� &� &� &� � � � �B �#� #� #� �X�#� � %� %� %� �X� %� � !� !� !� �X� !� �E� E� E� �X�E� �C� C� C� �X�C� � � � � �X� � � *� *� *� �X� *� � � � � �X� �0 �<� <� <� �X�<� �%� %� %� �X�%� �$� $� $� �X�$� �@� @� @� �X�@� �@� @� @� �X�@� �@� @� @� �X�@� @� @r$ �letterr �number� str | bytes | SupportsInt | Noner c �� � | rH|�d}| � � � } | dk rd} n| dk rd} n | dv rd} n| dv rd } | t |� � fS | s|rd } | t |� � fS d S ) Nr �alpha�a�beta�b)�cr �preview�rc)�rev�rr )�lowerr )r� r� s r% rb rb � s� � � � #� �>��F� � � � � �� �W� � ��F�F� �v� � ��F�F� �.� .� .��F�F� �|� #� #��F��s�6�{�{�"�"� � #�f� #� ���s�6�{�{�"�"� �4r$ z[\._-]r r c �l � | �1t d� t � | � � D � � � � S dS )zR Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). Nc 3 � K � | ];}|� � � s|� � � nt |� � V � �<d S r0 )�isdigitr� r )rR �parts r% rT z'_parse_local_version.<locals>.<genexpr>� sU � � � � � �� !%� � ��� =�D�J�J�L�L�L�C��I�I� � � � � � r$ )r` �_local_version_separatorsra )r s r% rc rc � sM � � ��� � �1�7�7��>�>� � � � � � � �4r$ r r r r r r r rL c �P � t t t t j d� t |� � � � � � � � � � }|� |� |�t }n |�t }n|}|�t }n|}|�t } n|} |�t } nt d� |D � � � � } | |||| | fS )Nc � � | dk S )Nr r# )ro s r% �<lambda>z_cmpkey.<locals>.<lambda> s � �A��F� r$ c 3 �Z K � | ]&}t |t � � r|d fnt |fV � �'dS )rq N)r9 r r rQ s r% rT z_cmpkey.<locals>.<genexpr>/ sP � � � � � �IJ�z�!�S�)�)� D�Q��G�G�0@�!�/D� � � � � � r$ )r` �reversed�list� itertools� dropwhiler r ) r r r r r r �_release�_pre�_post�_dev�_locals r% re re � s� � � ���i�)�*:�*:�H�W�<M�<M�N�N�O�O�P�P�� �H� �{�t�|���"2��� ������� �|�#3��� �� �{�"*��� �� �}� /��� � � �NS� � � � � �� �(�D�%��v� 5�5r$ )r& r' r( r )r� r r� r� r( r )r r r( r )r r r r r r r r r r r r r( rL )'r+ � __future__r r� r� �typingr r r r r r � _structuresr r r r �__all__r r' � LocalType�CmpPrePostDevType� CmpLocalTyperL r6 �VersionComparisonMethodr r � ValueErrorr r- �_VERSION_PATTERNr r rb r� r� rc re r# r$ r% �<module>r� s� ��� � #� "� "� "� "� "� � � � � � � � � G� G� G� G� G� G� G� G� G� G� G� G� G� G� G� G� W� W� W� W� W� W� W� W� W� W� W� W� C� C� C�� �%��S��/�3�&� '� ��,�(<�e�C��H�o�M�N� ��� �%��c�3�h���';�U�3��8�_�'L�!M�M� N�PS� S�T�V�� � �� �#�s�(�O����� � �� #�F�F�#3�T�#9�:� � � � � � �z� � � � � � � �� � � � �Z� � � �+'� +'� +'� +'� +'� +'� +'� +'�` � �> #�� �b@� b@� b@� b@� b@�l� b@� b@� b@�J � � � �F '�B�J�y� 1� 1� � � � � �;6� ;6� ;6� ;6� ;6� ;6r$ __pycache__/_elffile.cpython-311.pyc 0000644 00000012544 15004414131 0013222 0 ustar 00 � ]�bg� � �� � d Z ddlmZ ddlZddlZddlZddlmZ G d� de� � Z G d� dej � � Z G d � d ej � � Z G d � d ej � � Z G d � d� � ZdS )a; ELF file parser. This provides a class ``ELFFile`` that parses an ELF executable in a similar interface to ``ZipFile``. Only the read interface is implemented. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html � )� annotationsN)�IOc � � e Zd ZdS )� ELFInvalidN)�__name__� __module__� __qualname__� � �o/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/_elffile.pyr r s � � � � � ��Dr r c � � e Zd ZdZdZdS )�EIClass� � N)r r r �C32�C64r r r r r � � � � � � � �C� �C�C�Cr r c � � e Zd ZdZdZdS )�EIDatar r N)r r r �Lsb�Msbr r r r r r r r c �" � e Zd ZdZdZdZdZdZdS )�EMachine� � �( �> � N)r r r �I386�S390�Arm�X8664�AArc64r r r r r ! s' � � � � � � �D� �D� �C� �E� �F�F�Fr r c �: � e Zd ZdZdd�Zdd �Zedd �� � Zd S )�ELFFilez. Representation of an ELF executable. �f� IO[bytes]�return�Nonec � � || _ | � d� � }n"# t j $ r t d� � �w xY wt |d d� � � }|dk rt d|��� � �|d | _ |d | _ ddd d d �| j | j f \ }| _ | _ n.# t $ r! t d | j � d | j � d�� � �w xY w | � |� � \ }| _ }}| _ }| _ }| _ | _ d S # t j $ r}t d� � |�d }~ww xY w)N�16Bz unable to parse identification� s ELFzinvalid magic: � )z <HHIIIIIHHHz <IIIIIIII�r r r, )z >HHIIIIIHHHz >IIIIIIIIr. )z <HHIQQQIHHHz <IIQQQQQQ�r r r- )z >HHIQQQIHHHz >IIQQQQQQr/ ))r r )r r )r r )r r zunrecognized capacity (z) or encoding (�)z/unable to parse machine and section information)�_f�_read�struct�errorr �bytes�capacity�encoding�_p_fmt�_p_idx�KeyError�machine�_e_phoff�flags� _e_phentsize�_e_phnum)�selfr& �ident�magic�e_fmt�_�es r �__init__zELFFile.__init__. s� � ���� ?��J�J�u�%�%�E�E���|� ?� ?� ?� � =�>�>� >� ?�����e�B�Q�B�i� � �� �J� � � � 8�u� 8� 8�9�9� 9� �a��� � �a��� � � @�?�?�?� /� /� �}�d�m�,� /.� +�E�4�;�� � �� � � � � �.�$�-� .� .� !�]�.� .� .�� � � ���� W� � � �5�!�!� ��� ���� ��� ���!�� � � ���|� W� W� W� � N�O�O�UV� V����� W���s, � � >� 'B3 �3+C �"9D � E�,D<�<E�fmt�str�tuple[int, ...]c � � t j || j � t j |� � � � � � S )N)r3 �unpackr1 �read�calcsize)r@ rG s r r2 z ELFFile._read\ s, � ��}�S�$�'�,�,�v��s�/C�/C�"D�"D�E�E�Er � str | Nonec � � t | j � � D ]�}| j � | j | j |z z � � | � | j � � }n# t j $ r Y �Yw xY w|| j d dk r�u| j � || j d � � t j | j � || j d � � � � � d� � c S dS )zH The path recorded in the ``PT_INTERP`` section header. r r r r � N)�ranger? r1 �seekr< r> r2 r8 r3 r4 r9 �os�fsdecoderL �strip)r@ �index�datas r � interpreterzELFFile.interpreter_ s� � � �4�=�)�)� O� O�E� �G�L�L�� ��):�U�)B�B� C� C� C� ��z�z�$�+�.�.�����<� � � ��� �����D�K��N�#�q�(�(�� �G�L�L��d�k�!�n�-� .� .� .��;�t�w�|�|�D���Q� �,@� A� A�B�B�H�H��N�N� N� N� N��ts �A � A/�.A/N)r& r' r( r) )rG rH r( rI )r( rN )r r r �__doc__rF r2 �propertyrX r r r r% r% ) so � � � � � �� �,W� ,W� ,W� ,W�\F� F� F� F� �� � � �X�� � r r% )rY � __future__r �enumrS r3 �typingr � ValueErrorr �IntEnumr r r r% r r r �<module>r` s: ��� � #� "� "� "� "� "� � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � �d�l� � � � � � � � �T�\� � � � � � � � �t�|� � � �E� E� E� E� E� E� E� E� E� Er __pycache__/_parser.cpython-311.pyc 0000644 00000037657 15004414131 0013124 0 ustar 00 � ]�bg�' � �� � d Z ddlmZ ddlZddlmZmZmZmZ ddl m Z m Z G d� d� � Z G d � d e � � Z G d � d e � � Z G d � de � � Zee ef Zeeeef Zeeed f Zeedeef Z G d� de� � Zd2d�Zd3d�Zd4d�Zd5d �Zd6d!�Zd6d"�Zd7d#�Z d7d$�Z d8d%�Z d9d&�Z d9d'�Z d:d(�Z!d;d*�Z"d<d,�Z#d=d.�Z$d>d0�Z%d?d1�Z&dS )@z�Handwritten parser of dependency specifiers. The docstring for each __parse_* function contains EBNF-inspired grammar representing the implementation. � )� annotationsN)� NamedTuple�Sequence�Tuple�Union� )� DEFAULT_RULES� Tokenizerc �. � e Zd Zd d�Zd d�Zd d�Zd d�Zd S ) �Node�value�str�return�Nonec � � || _ d S �N�r )�selfr s �n/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/_parser.py�__init__z Node.__init__ s � ��� � � � c � � | j S r r �r s r �__str__z Node.__str__ s � ��z�r c �( � d| j j � d| � d�S )N�<z('z')>)� __class__�__name__r s r �__repr__z Node.__repr__ s � �7�4�>�*�7�7�d�7�7�7�7r c � � t �r )�NotImplementedErrorr s r � serializezNode.serialize s � �!�!r N)r r r r �r r )r � __module__� __qualname__r r r r" � r r r r sd � � � � � �� � � �� � � �8� 8� 8� 8�"� "� "� "� "� "r r c � � e Zd Zdd�ZdS )�Variabler r c � � t | � � S r �r r s r r" zVariable.serialize � � ��4�y�y�r Nr# �r r$ r% r" r& r r r( r( �( � � � � � �� � � � � r r( c � � e Zd Zdd�ZdS )�Valuer r c � � d| � d�S )N�"r& r s r r" zValue.serialize# s � ��4�{�{�{�r Nr# r, r& r r r/ r/ " s( � � � � � �� � � � � r r/ c � � e Zd Zdd�ZdS )�Opr r c � � t | � � S r r* r s r r" z Op.serialize( r+ r Nr# r, r& r r r3 r3 ' r- r r3 � MarkerAtom� MarkerListc �B � e Zd ZU ded< ded< ded< ded< ded< d S ) �ParsedRequirementr �name�url� list[str]�extras� specifierzMarkerList | None�markerN)r r$ r% �__annotations__r& r r r8 r8 2 sE � � � � � � � �I�I�I� �H�H�H������N�N�N� � � � � � r r8 �sourcer r c �H � t t | t �� � � � S �N)�rules)�_parse_requirementr r �r@ s r �parse_requirementrF = � � � �i��m� D� D� D� E� E�Er � tokenizerr c �T � | � d� � | � dd�� � }|j }| � d� � t | � � }| � d� � t | � � \ }}}| � dd�� � t |||||� � S )zI requirement = WS? IDENTIFIER WS? extras WS? requirement_details �WS� IDENTIFIERz1package name at the start of dependency specifier��expected�ENDzend of dependency specifier)�consume�expect�text� _parse_extras�_parse_requirement_detailsr8 )rH � name_tokenr9 r< r: r= r> s r rD rD A s� � � ���d�����!�!�� R� "� � �J� �?�D� ���d���� �9� %� %�F� ���d���� 7� � B� B��C��F� ���U�%B��C�C�C� �T�3�� �6� B� B�Br �"tuple[str, str, MarkerList | None]c �X � d}d}d}| � d� � r�| � � � | � d� � | j }| � dd�� � j }| � dd � � � r|||fS | � dd �� � | � dd � � � r|||fS t | |d � � � }n]| j }t | � � }| � d� � | � dd � � � r|||fS t | ||rdnd� � � }|||fS )z~ requirement_details = AT URL (WS requirement_marker?)? | specifier WS? (requirement_marker)? � N�ATrJ �URLz URL after @rL rN T��peekzwhitespace after URLzURL and whitespace)� span_start�after�version specifierz#name and no valid version specifier)�check�readrO �positionrP rQ �_parse_requirement_marker�_parse_specifier)rH r= r: r> � url_start�specifier_starts r rS rS V s~ � � �I� �C� �F����t� � � " ����������$� � � � �&� �� � �u�}� �=�=�B�� �?�?�5�t�?� ,� ,� ,���F�+� +�����(>��?�?�?� �?�?�5�t�?� ,� ,� ,���F�+� +�*� �)�3G� � � ��� $�,��$�Y�/�/� ����$� � � � �?�?�5�t�?� ,� ,� ,���F�+� +�*� �&� �;�#�#�:� � � �� ��F� #�#r r\ �intr] c �� � | � d� � s| � d|� d�|�� � | � � � t | � � }| � d� � |S )z3 requirement_marker = SEMICOLON marker WS? � SEMICOLONz!Expected end or semicolon (after �))r\ rJ )r_ �raise_syntax_errorr` � _parse_markerrO )rH r\ r] r> s r rb rb � s~ � � �?�?�;� '� '� ��$�$� 8�� 8� 8� 8�!� %� � � � �N�N���� �9� %� %�F� ���d���� �Mr r; c � � | � dd�� � sg S | � ddd�� � 5 | � d� � t | � � }| � d� � ddd� � n # 1 swxY w Y |S ) zG extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? � LEFT_BRACKETTrZ � RIGHT_BRACKETr< ��aroundrJ N)r_ �enclosing_tokensrO �_parse_extras_list)rH r< s r rR rR � s� � � �?�?�>��?� 5� 5� �� � � #� #���� $� � � � � ���$� � � �#�I�.�.�����$� � � � � � � � � � � � � � ���� � � � � �Ms �:A8�8A<�?A<c � � g }| � d� � s|S |� | � � � j � � | � d� � | � dd�� � r| � d� � n| � d� � sn[| � � � | � d� � | � dd�� � }|� |j � � ��|S ) z> extras_list = identifier (wsp* ',' wsp* identifier)* rK TrJ rZ z"Expected comma between extra names�COMMAzextra name after commarL )r_ �appendr` rQ rO rj rP )rH r< � extra_tokens r rr rr � s� � � �F� �?�?�<� (� (� �� � �M�M�)�.�.�"�"�'�(�(�(� (����$� � � � �?�?�<�d�?� 3� 3� � � (� (�)M� N� N� N� N�� � ��)�)� � ����������$� � � � �&�&�|�>V�&�W�W� �� � �k�&�'�'�'� (� �Mr c �� � | � ddd�� � 5 | � d� � t | � � }| � d� � ddd� � n # 1 swxY w Y |S )zr specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS | WS? version_many WS? �LEFT_PARENTHESIS�RIGHT_PARENTHESISr^ ro rJ N)rq rO �_parse_version_many)rH �parsed_specifierss r rc rc � s� � � � #� #���"� $� � � � � ���$� � � � /� � :� :�����$� � � � � � � � � � � � � � ���� � � � � � s �:A � A#�&A#c �2 � d}| � d� � r�| j }|| � � � j z }| � dd�� � r | � d|| j dz �� � | � d d�� � r | � d || j �� � | � d � � | � d � � snF|| � � � j z }| � d � � | � d� � ��|S ) z@ version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? rW � SPECIFIER�VERSION_PREFIX_TRAILTrZ z6.* suffix can only be used with `==` or `!=` operatorsr )r\ �span_end�VERSION_LOCAL_LABEL_TRAILz@Local version label can only be used with `==` or `!=` operatorsrJ rt )r_ ra r` rQ rj rO )rH r{ r\ s r rz rz � s@ � � �� �/�/�+� &� &� � �'� ��Y�^�^� -� -� 2�2�� �?�?�1��?� =� =� � � (� (�H�%�"�+�a�/� )� � � � �?�?�6�T�?� B� B� � � (� (�R�%�"�+� )� � � � ���$� � � ����w�'�'� � ��Y�^�^� -� -� 2�2�����$� � � �' �/�/�+� &� &� �* � r c �H � t t | t �� � � � S rB )�_parse_full_markerr r rE s r � parse_markerr� � rG r c �R � t | � � }| � dd�� � |S )NrN zend of marker expressionrL )rk rP )rH �retvals r r� r� s. � � �9� %� %�F� ���U�%?��@�@�@� �Mr c � � t | � � g}| � d� � rT| � � � }t | � � }|� |j |f� � | � d� � �T|S )z4 marker = marker_atom (BOOLOP marker_atom)+ �BOOLOP)�_parse_marker_atomr_ r` �extendrQ )rH � expression�token� expr_rights r rk rk s} � � %�Y�/�/�0�J� �/�/�(� #� #� 4���� � ��'� �2�2� ����5�:�z�2�3�3�3� �/�/�(� #� #� 4� �r c �z � | � d� � | � dd�� � rj| � ddd�� � 5 | � d� � t | � � }| � d� � ddd� � n # 1 swxY w Y nt | � � }| � d� � |S ) zw marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? | WS? marker_item WS? rJ rx TrZ ry zmarker expressionro N)rO r_ rq rk �_parse_marker_item)rH r> s r r� r� s � � ���d�������)���5�5� /� � '� '� � �&� (� � � $� $� � � �d� #� #� #�!.�y�!9�!9�F� � � �d� #� #� #� $� $� $� $� $� $� $� $� $� $� $���� $� $� $� $�� $�I�.�.�� ���d���� �Ms �:B � B�B� MarkerItemc � � | � d� � t | � � }| � d� � t | � � }| � d� � t | � � }| � d� � |||fS )zG marker_item = WS? marker_var WS? marker_op WS? marker_var WS? rJ )rO �_parse_marker_var�_parse_marker_op)rH �marker_var_left� marker_op�marker_var_rights r r� r� ( s� � � ���d����'� �2�2�O� ���d���� ��+�+�I� ���d����(��3�3�� ���d���� �Y�(8� 9�9r � MarkerVarc �F � | � d� � r:t | � � � j � dd� � � � S | � d� � r&t | � � � j � � S | � d�� � dS )z/ marker_var = VARIABLE | QUOTED_STRING �VARIABLE�.�_� QUOTED_STRINGz+Expected a marker variable or quoted string)�messageN)r_ �process_env_varr` rQ �replace�process_python_strrj �rH s r r� r� 6 s� � � ���z�"�"� � �y�~�~� /� /� 4� <� <�S�#� F� F�G�G�G� � � � � )� )� �!�)�.�.�"2�"2�"7�8�8�8��$�$�A� %� � � � � r �env_varc �F � | dv rt d� � S t | � � S )N)� platform_python_implementation�python_implementationr� )r( )r� s r r� r� D s+ � ��M�M�M��8�9�9�9��� � � r � python_strc �b � t j | � � }t t |� � � � S r )�ast� literal_evalr/ r )r� r s r r� r� K s& � � � �Z� (� (�E� ��U��� � � r c �� � | � d� � r#| � � � t d� � S | � d� � rQ| � � � | � dd�� � | � dd�� � t d� � S | � d � � r&t | � � � j � � S | � d � � S ) z& marker_op = IN | NOT IN | OP �IN�in�NOTrJ zwhitespace after 'not'rL z'in' after 'not'znot in�OPzJExpected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in)r_ r` r3 rP rQ rj r� s r r� r� P s� � � ���t� � � ��������$�x�x�� � � �� � � �����������(@��A�A�A�����(:��;�;�;��(�|�|�� � � �� � � ��)�.�.�"�"�'�(�(�(��+�+� 8� � � r )r@ r r r8 )rH r r r8 )rH r r rU )rH r r\ rf r] r r r6 )rH r r r; )rH r r r )r@ r r r6 )rH r r r6 )rH r r r5 )rH r r r� )rH r r r� )r� r r r( )r� r r r/ )rH r r r3 )'�__doc__� __future__r r� �typingr r r r � _tokenizerr r r r( r/ r3 r� r� r5 r r6 r8 rF rD rS rb rR rr rc rz r� r� rk r� r� r� r� r� r� r& r r �<module>r� s� ��� � #� "� "� "� "� "� � � � � 5� 5� 5� 5� 5� 5� 5� 5� 5� 5� 5� 5� 0� 0� 0� 0� 0� 0� 0� 0� "� "� "� "� "� "� "� "� � � � � �t� � � � � � � � �D� � � � � � � � �� � � � �(�E�/� "� � �9�b�)�+� ,� � �:�x� � 5�5� 6� � �e�L�*�c� 9�:� ;� � � � � � � � � � �F� F� F� F�C� C� C� C�*0$� 0$� 0$� 0$�f� � � �(� � � �&� � � �6 � � � �" � � � �@F� F� F� F�� � � � � � � �� � � �, :� :� :� :� � � � � !� !� !� !� � � � � � � � � � r __pycache__/_tokenizer.cpython-311.pyc 0000644 00000020570 15004414131 0013624 0 ustar 00 � ]�bg� � �� � U d dl mZ d dlZd dlZd dlmZ d dlmZmZ ddl m Z e G d� d� � � � Z G d � d e � � Z i d d �d d�dd�dd�dd�dd�d ej dej � � �dd�dd �d d �d d �d! ej d"ej � � �d# ej e j e j z ej ej z � � �d$d%�d&d'�d(d)�d*d+�d,d-d.d/��Zd0ed1< G d2� d3� � ZdS )4� )� annotationsN)� dataclass)�Iterator�NoReturn� )� Specifierc �. � e Zd ZU ded< ded< ded< dS )�Token�str�name�text�int�positionN)�__name__� __module__� __qualname__�__annotations__� � �q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/_tokenizer.pyr r s+ � � � � � � � �I�I�I� �I�I�I��M�M�M�M�Mr r c �, � � e Zd ZdZd � fd � Zd d �Z� xZS ) �ParserSyntaxErrorz7The provided source text could not be parsed correctly.�messager �source�span�tuple[int, int]�return�Nonec �r �� || _ || _ || _ t � � � � � d S )N)r r r �super�__init__)�selfr r r � __class__s �r r! zParserSyntaxError.__init__ s6 �� � �� � �� � �� � ���������r c � � d| j d z d| j d | j d z z z dz }d� | j | j |g� � S )N� r �~r �^z )r �joinr r )r" �markers r �__str__zParserSyntaxError.__str__" sO � ��t�y��|�#�c�T�Y�q�\�D�I�a�L�-H�&I�I�C�O���}�}�d�l�D�K�� @�A�A�Ar )r r r r r r r r )r r )r r r �__doc__r! r* � __classcell__)r# s @r r r s_ �� � � � � �A�A� � � � � � �B� B� B� B� B� B� B� Br r �LEFT_PARENTHESISz\(�RIGHT_PARENTHESISz\)� LEFT_BRACKETz\[� RIGHT_BRACKETz\]� SEMICOLON�;�COMMA�,� QUOTED_STRINGzk ( ('[^']*') | ("[^"]*") ) �OPz(===|==|~=|!=|<=|>=|<|>)�BOOLOPz \b(or|and)\b�INz\bin\b�NOTz\bnot\b�VARIABLEa� \b( python_version |python_full_version |os[._]name |sys[._]platform |platform_(release|system) |platform[._](version|machine|python_implementation) |python_implementation |implementation_(name|version) |extra )\b � SPECIFIER�ATz\@�URLz[^ \t]+� IDENTIFIERz \b[a-zA-Z0-9][a-zA-Z0-9._-]*\b�VERSION_PREFIX_TRAILz\.\*z \+[a-z0-9]+(?:[-_\.][a-z0-9]+)*z[ \t]+�$)�VERSION_LOCAL_LABEL_TRAIL�WS�END� dict[str, str | re.Pattern[str]]� DEFAULT_RULESc �r � e Zd ZdZd!d�Zd"d �Zd d �d#d�Zd$d�Zd%d�Zddd�d&d�Z e j d'd �� � Z dS )(� Tokenizerz�Context-sensitive token parsing. Provides methods to examine the input stream to check whether the next token matches. r r �rulesrD r r c �v � || _ d� |� � � D � � | _ d | _ d| _ d S )Nc �> � i | ]\ }}|t j |� � ��S r )�re�compile)�.0r �patterns r � <dictcomp>z&Tokenizer.__init__.<locals>.<dictcomp>h s5 � � 2 � 2 � 2 �*7�$��D�"�*�W�%�%�2 � 2 � 2 r r )r �itemsrH � next_tokenr )r" r rH s r r! zTokenizer.__init__a sG � � �� �2 � 2 �;@�;�;�=�=�2 � 2 � 2 �� � )-����� � � r r c �\ � | � |� � r| � � � dS dS )z8Move beyond provided token name, if at current position.N)�check�read)r" r s r �consumezTokenizer.consumen s1 � � �:�:�d� � � � �I�I�K�K�K�K�K� � r F)�peekrV �boolc � � | j �J d|�d| j ��� � �|| j v s J d|��� � �| j | }|� | j | j � � }|�dS |s!t ||d | j � � | _ dS )z�Check whether the next token has the provided name. By default, if the check succeeds, the token *must* be read before another check. If `peek` is set to `True`, the token is not loaded and would need to be checked again. NzCannot check for z, already have zUnknown token name: Fr T)rQ rH �matchr r r )r" r rV � expressionrY s r rS zTokenizer.checks s� � � �O� #� #� I�t� I� I�d�o� I� I� $� #� #��t�z�!�!�!�#B�$�#B�#B�!�!�!��Z��%� �� � ���d�m�<�<�� �=��5�� C� #�D�%��(�D�M� B� B�D�O��tr �expectedr c � � | � |� � s| � d|� �� � �| � � � S )zsExpect a certain token name next, failing with a syntax error otherwise. The token is *not* read. z Expected )rS �raise_syntax_errorrT )r" r r[ s r �expectzTokenizer.expect� sD � � �z�z�$� � � B��)�)�*@�h�*@�*@�A�A� A��y�y�{�{�r c �n � | j }|�J �| xj t |j � � z c_ d| _ |S )z%Consume the next token and return it.N)rQ r �lenr )r" �tokens r rT zTokenizer.read� s9 � ����� � � � � � ��U�Z� � �(� � � ���� r N)� span_start�span_endr rb � int | Nonerc r c �\ � |�| j n||�| j n|f}t || j |�� � �)z.Raise ParserSyntaxError at the given position.N)r r )r r r )r" r rb rc r s r r] z Tokenizer.raise_syntax_error� sK � � (� /�D�M�M�Z� %� -�D�M�M�8� �� � ��;�� � � � r � open_token� close_token�around�Iterator[None]c # � K � | � |� � r | j }| � � � nd }d V � |�d S | � |� � s | � d|� d|� d|� �|�� � | � � � d S )NzExpected matching z for z, after )rb )rS r rT r] )r" rf rg rh � open_positions r �enclosing_tokenszTokenizer.enclosing_tokens� s� � � � � �:�:�j� !� !� !� �M�M� �I�I�K�K�K�K� �M� ���� � � �F��z�z�+�&�&� � � #� #�S�[�S�S�z�S�S�6�S�S�(� $� � � � � � � � � � � r )r r rH rD r r )r r r r )r r rV rW r rW )r r r[ r r r )r r )r r rb rd rc rd r r )rf r rg r rh r r ri ) r r r r+ r! rU rS r^ rT r] � contextlib�contextmanagerrl r r r rG rG Z s� � � � � � �� � � � � �� � � � 05� � � � � � �*� � � �� � � � "&� #� � � � � � �$ � �� � � � �� � r rG )� __future__r rm rK � dataclassesr �typingr r � specifiersr r � Exceptionr rL �VERBOSE�_operator_regex_str�_version_regex_str� IGNORECASErE r rG r r r �<module>rx sv �� "� "� "� "� "� "� "� � � � � � � � � !� !� !� !� !� !� %� %� %� %� %� %� %� %� !� !� !� !� !� !� �� � � � � � � ��� B� B� B� B� B� � B� B� B�*03���03���03� �E�03� �U� 03� �� 03� �T� 03� �Z�R�Z� � � � � �03�" � %�#03�$ �o�%03�& �)�'03�( �:�)03�* � �� � � � � � �+03�J �����%� �(D�D� � �R�]�"�� �K03�R �%�S03�T �:�U03�V �3�W03�X �G�Y03�Z "D� � �_03� 03� 03� � 0� 0� 0� 0�fh� h� h� h� h� h� h� h� h� hr __pycache__/metadata.cpython-311.pyc 0000644 00000067617 15004414131 0013250 0 ustar 00 � ]�bg]~ � � � d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlm Z m Z m Z m Z m Z mZ ddlmZmZmZ ddlmZ ej d� � Z e eZn# e$ r G d� d e� � ZY nw xY w G d � d e� � Z G d � d e d�� � Z h d�Z h d�Z dhZ dMd�Z dNd�Z!dOd �Z"i d d �d d!�d"d#�d$d$�d%d&�d'd(�d)d)�d*d+�d,d,�d-d-�d.d.�d/d0�d1d2�d3d3�d4d4�d5d6�d7d8�dd9d:d;d<d=d>d?d@dAdBdC� �Z#dD� e#�$ � � D � � Z%dPdF�Z& e'� � Z(g dG�Z)e dG Z* e+g dH�� � Z, G dI� dJe e � � Z- G dK� dL� � Z.dS )Q� )� annotationsN)�Any�Callable�Generic�Literal� TypedDict�cast� )� requirements� specifiers�utils)�version�Tc �8 � e Zd ZU dZded< ded< d d�Zd d �Zd S ) �ExceptionGroupz�A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11. If :external:exc:`ExceptionGroup` is already defined by Python itself, that version is used instead. �str�message�list[Exception]� exceptions�return�Nonec �" � || _ || _ d S �N)r r )�selfr r s �o/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/pip/_vendor/packaging/metadata.py�__init__zExceptionGroup.__init__& s � �"�D�L� (�D�O�O�O� c �@ � | j j � d| j �d| j �d�S )N�(z, �))� __class__�__name__r r )r s r �__repr__zExceptionGroup.__repr__* s* � ��n�-�V�V�� �V�V�$�/�V�V�V� Vr N)r r r r r r )r r )r" � __module__� __qualname__�__doc__�__annotations__r r# � r r r r se � � � � � � � � � � � � �#�#�#�#� )� )� )� )� W� W� W� W� W� Wr r c �2 � � e Zd ZU dZded< d� fd� Z� xZS ) �InvalidMetadataz'A metadata field contains invalid data.r �fieldr r r c �X �� || _ t � � � |� � d S r )r+ �superr )r r+ r r! s �r r zInvalidMetadata.__init__7 s( �� ��� � ������!�!�!�!�!r )r+ r r r r r )r" r$ r% r& r' r � __classcell__)r! s @r r* r* 1 sQ �� � � � � � �1�1��J�J�J�;�"� "� "� "� "� "� "� "� "� "r r* c �, � e Zd ZU dZded< ded< ded< ded< ded< ded < ded < ded < ded < ded < ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< d ed < ded < ded < ded < d!S )"� RawMetadataa� A dictionary of raw core metadata. Each field in core metadata maps to a key of this dictionary (when data is provided). The key is lower-case and underscores are used instead of dashes compared to the equivalent core metadata field. Any core metadata field that can be specified multiple times or can hold multiple values in a single field have a key with a plural name. See :class:`Metadata` whose attributes match the keys of this dictionary. Core metadata fields that can be specified multiple times are stored as a list or dict depending on which is appropriate for the field. Any fields which hold multiple values in a single field are stored as a list. r �metadata_version�namer � list[str]� platforms�summary� description�keywords� home_page�author� author_email�license�supported_platforms� download_url� classifiers�requires�provides� obsoletes� maintainer�maintainer_email� requires_dist� provides_dist�obsoletes_dist�requires_python�requires_external�dict[str, str]� project_urls�description_content_type�provides_extra�dynamicN)r" r$ r% r& r' r( r r r0 r0 @ sa � � � � � � � � � ���� �I�I�I��L�L�L������L�L�L����������N�N�N��K�K�K������L�L�L� #�"�"�"��������������������� �O�O�O����� � � � � � � � � � � � ����� � � � � � � � � "�!�!�!� � � � � �����r r0 F)�total> r2 r9 r; r5 r r8 rB r6 r: r= rG rC r1 rK > rM r@ r? rA r4 r> rE rD rF rL rH r< rJ �datar r r3 c �@ � d� | � d� � D � � S )zCSplit a string of comma-separate keyboards into a list of keywords.c �6 � g | ]}|� � � ��S r( ��strip)�.0�ks r � <listcomp>z#_parse_keywords.<locals>.<listcomp>� s � � /� /� /�!�A�G�G�I�I� /� /� /r �,)�split)rO s r �_parse_keywordsrY � s � � /� /�t�z�z�#��� /� /� /�/r rI c � � i }| D ]v}d� |� dd� � D � � }|� dgt ddt |� � z � � z � � |\ }}||v rt d� � �|||< �w|S )z?Parse a list of label/URL string pairings separated by a comma.c �6 � g | ]}|� � � ��S r( rR )rT �ps r rV z'_parse_project_urls.<locals>.<listcomp>� s � �7�7�7�q������7�7�7r rW r � r � z duplicate labels in project urls)rX �extend�max�len�KeyError)rO �urls�pair�parts�label�urls r �_parse_project_urlsrh � s� � � �D�� � ��$ 8�7�D�J�J�s�A�$6�$6�7�7�7�� � � �b�T�S��A��E� � �N� 3� 3�4�5�5�5� � ��s� �D�=�=� �=�>�>� >���U� � � �Kr �msg�email.message.Message�source� bytes | strc �� � t |t � � r| � � � }|S | � d�� � } |� dd� � S # t $ r t d� � �w xY w)z Get the body of the message.T��decode�utf8�strictz payload in an invalid encoding)� isinstancer � get_payloadro �UnicodeDecodeError� ValueError)ri rk �payload�bpayloads r � _get_payloadrx � s� � � �&�#� � � ?����(�(���� �/�/��/�6�6�� ?��?�?�6�8�4�4� 4��!� ?� ?� ?� � =�>�>� >� ?���s �A �A3r9 z author-emailr: � classifierr> r6 zdescription-content-typerK z download-urlr= rM z home-pager8 r7 r; rB zmaintainer-emailrC �metadata-versionr1 r2 rA zobsoletes-distrF �platformr4 r@ rE rL r? rD rH rG r5 r< r ) z project-urlr@ z provides-distzprovides-extrar? z requires-distzrequires-externalzrequires-pythonr5 zsupported-platformr c � � i | ]\ }}||�� S r( r( )rT �email�raws r � <dictcomp>r s � �T�T�T� ��s��e�T�T�Tr �(tuple[RawMetadata, dict[str, list[str]]]c � � i }i }t | t � � rCt j � t j j �� � � | � � }nBt j � t j j �� � � | � � }t |� � � � � D �]}|� � � }|� |� � pg }g }d}|D �] }t |t j j t f� � sJ �t |t j j � � r�g } t j � |� � D ]J\ } } | � dd� � d} n# t$ $ r d} d}Y nw xY w| � | | f� � �K|� t t j � | � � � � � � ��|� |� � �� |s|||< ��Jt* � |� � } | �|||< ��m| t. v r t1 |� � dk r |d || < ���| t2 v r||| < ���| d k r-t1 |� � dk rt5 |d � � || < ���| d k r+ t7 |� � || < ���# t8 $ r |||< Y ��w xY w|||< �� t; || � � } | r}d |v rTt= t |� d � � � � }|� d g � � �! || g� � n�d |v r |d � | � � nf| |d < n`# tD $ rS |� d g � � � |�# t | tH � � � � � � � Y nw xY wt= tJ |� � |fS )a Parse a distribution's metadata stored as email headers (e.g. from ``METADATA``). This function returns a two-item tuple of dicts. The first dict is of recognized fields from the core metadata specification. Fields that can be parsed and translated into Python's built-in types are converted appropriately. All other fields are left as-is. Fields that are allowed to appear multiple times are stored as lists. The second dict contains all other fields from the metadata. This includes any unrecognized fields. It also includes any fields which are expected to be parsed into a built-in type but were not formatted appropriately. Finally, any fields that are expected to appear only once but are repeated are included in this dict. )�policyTrp rq �latin1FNr r r7 rJ r6 rn )&rr r r} �parser�Parserr� �compat32�parsestr� BytesParser� parsebytes� frozenset�keys�lower�get_all�header�Header� decode_headerro rt �append� make_header�_EMAIL_TO_RAW_MAPPING�get�_STRING_FIELDSra � _LIST_FIELDSrY rh rb rx r �pop� setdefaultr_ ru rs �bytesr0 )rO r~ �unparsed�parsedr2 �headers�value�valid_encoding�h�chunks�bin�encoding�raw_namerv �description_headers r � parse_emailr� s/ � � 8:�C�%'�H��$�� � � Y�� �$�$�E�L�,A�$�B�B�K�K�D�Q�Q���� �)�)�� �1F�)�G�G�R�R�SW�X�X�� �&�+�+�-�-�(�(� t#� t#�� �z�z�|�|�� �.�.��&�&�,�"�� �� ��� # � # �A� �a�%�,�"5�s�!;�<�<� <� <�<� �!�U�\� 0�1�1� � :<��%*�\�%?�%?��%B�%B� 3� 3�M�C��*�� � �6�8�4�4�4� $*���� .� /� /� /�#+��).����/���� �M�M�3��/�2�2�2�2� � � �S�� �!9�!9�&�!A�!A� B� B�C�C�C�C� � � �Q����� � � "�H�T�N� �(�,�,�T�2�2�� � � #�H�T�N� � �~� %� %�#�e�*�*��/�/� !�!�H�C��M�M� � � %� %� !�C��M�M� �� #� #��E� � �a��� +�E�!�H� 5� 5�C��M�M� � � '� '� '� 3�E� :� :��H� � ��� '� '� '�!&������ '���� #�H�T�N�N� -� �v�t�,�,�� � -� ��#�#�%)�#�s�w�w�}�/E�/E�%F�%F�"��#�#�M�2�6�6�=�=�'��1�� � � � �(�*�*�� �'�.�.�w�7�7�7�7�%,��M�"���! � � � ����M�2�.�.�5�5� � � �j��u�&=�&=� � >� >� � � � � � ����, � �S� !� !�8� +�+s7 �%E>�>F �F � J4�4K�K�M" �"AN?�>N?)�1.0�1.1�1.2�2.1�2.2z2.3)r1 r2 r c � � e Zd ZU dZded< ded< ded< dd�d(d �Zd)d�Zd*d�Z d+d,d�Zd-d�Z d.d�Z d/d �Z d.d �Z d.d �Z d0d!�Zd1d#�Zd2d%�Zd3d'�ZdS )4� _Validatorav Validate a metadata field. All _process_*() methods correspond to a core metadata field. The method is called with the field's raw value. If the raw value is valid it is returned in its "enriched" form (e.g. ``version.Version`` for the ``Version`` field). If the raw value is invalid, :exc:`InvalidMetadata` is raised (with a cause as appropriate). r r2 r� �_MetadataVersion�addedr� �r� r r c � � || _ d S r r� )r r� s r r z_Validator.__init__� s � � �� � � r �_owner�Metadatac �8 � || _ t | | _ d S r )r2 �_RAW_TO_EMAIL_MAPPINGr� )r r� r2 s r � __set_name__z_Validator.__set_name__� s � ��� �-�d�3�� � � r �instance�type[Metadata]r c �T � |j }|j � | j � � }| j t v s|�5 t | d| j � �� � } ||� � }n# t $ r Y nw xY w||| j < |j | j = n# t $ r Y nw xY wt t |� � S )N� _process_) �__dict__�_rawr� r2 �_REQUIRED_ATTRS�getattr�AttributeErrorrb r r )r r� r� �cacher� � converters r �__get__z_Validator.__get__� s� � � �!��� �!�!�$�)�,�,�� �9�� '� '�5�+<� )�07��>U�$�)�>U�>U�0V�0V� � "� �%�(�(���� "� � � ��� ���� !��d�i�� �� �d�i�(�(��� � � � �D� ���� �A�u�~�~� s# �A � A)�(A)�7 B � B�BNri �cause�Exception | Noner* c � � t | j |� dt | j � � i� � � � }||_ |S )Nr+ )r* r� � format_map�repr� __cause__)r ri r� �excs r �_invalid_metadataz _Validator._invalid_metadata sC � � � �M�3�>�>�7�D�� �4G�4G�*H�I�I� � �� �� �� r r� c �n � |t vr| � |�d�� � �t t |� � S )Nz is not a valid metadata version)�_VALID_METADATA_VERSIONSr� r r� �r r� s r �_process_metadata_versionz$_Validator._process_metadata_version s< � � �0� 0� 0��(�(�E�)U�)U�)U�V�V� V��$�e�,�,�,r c �� � |s| � d� � � t j |d�� � |S # t j $ r }| � |�d�|�� � �d }~ww xY w)N�{field} is a required fieldT��validate� is invalid for {field}�r� )r� r �canonicalize_name� InvalidName�r r� r� s r � _process_namez_Validator._process_name s� � �� H��(�(�)F�G�G� G� � � #�E�D� 9� 9� 9� 9� �L�� � � � � ��(�(��5�5�5�S� )� � � ����� ���s �1 �A � A�A �version_module.Versionc � � |s| � d� � � t j |� � S # t j $ r }| � |�d�|�� � �d }~ww xY w)Nr� r� r� )r� �version_module�parse�InvalidVersionr� s r �_process_versionz_Validator._process_version s� � �� H��(�(�)F�G�G� G� �!�'��.�.� .�� �,� � � ��(�(��5�5�5�S� )� � � ����� ���s �- �A�A�Ac �8 � d|v r| � d� � �|S )z%Check the field contains no newlines.� z {field} must be a single line)r� r� s r �_process_summaryz_Validator._process_summary( s% � � �5�=�=��(�(�)H�I�I� I�� r c �X � h d�}t j � � � }||d< |� � � � � � |d j }}||vs||� � � vr(| � dt |� � � d|��� � �|� dd� � }|dk r%| � dt |� � � �� � �dd h}|� d d� � }|d k r,||vr(| � d t |� � � d|��� � �|S ) N> � text/plain� text/x-rst� text/markdownz content-typez{field} must be one of z, not �charsetzUTF-8z0{field} can only specify the UTF-8 charset, not �GFM� CommonMark�variantr� z(valid Markdown variants for {field} are ) r} r � EmailMessage�get_content_typer� �paramsr� �listr� ) r r� � content_typesr � content_type� parametersr� �markdown_variantsr� s r �!_process_description_content_typez,_Validator._process_description_content_type. sp � �E�E�E� ��-�,�,�.�.��"'��� � � $� $� &� &� ,� ,� .� .� �N� #� *� !� � �}� ,� ,� �E�K�K�M�M�0Q�0Q��(�(�P�D� �,?�,?�P�P�u�P�P�� � � �.�.��G�4�4�� �g� � ��(�(�T�T�'�]�]�T�T�� � � #�L� 1�� �.�.��E�2�2�� �?� *� *�w�>O�/O�/O��(�(�#�T�BS�=T�=T� #� #� �#� #�� � � � r r3 c � � t t j |� � D ]?}|dv r| � |�d�� � �|t vr| � |�d�� � ��@t t t j |� � � � S )N> r2 r rz z" is not allowed as a dynamic fieldz is not a valid dynamic field)�mapr r� r� r� r� )r r� � dynamic_fields r �_process_dynamicz_Validator._process_dynamicN s� � � ���E� 2� 2� X� X�M� � G�G�G��,�,� �B�B�B�� � � �&;�;�;��,�,��-V�-V�-V�W�W�W� <��C�� �5�)�)�*�*�*r �list[utils.NormalizedName]c �� � g } |D ]+}|� t j |d�� � � � �, |S # t j $ r }| � |�d�|�� � �d }~ww xY w)NTr� r� r� )r� r r� r� r� )r r� �normalized_namesr2 r� s r �_process_provides_extraz"_Validator._process_provides_extraX s� � � �� $� � V� V�� �'�'��(?��t�(T�(T�(T�U�U�U�U� V� $� #�� � � � � ��(�(��4�4�4�C� )� � � ����� ���s �.5 �A#�A � A#�specifiers.SpecifierSetc � � t j |� � S # t j $ r }| � |�d�|�� � �d }~ww xY w�Nr� r� )r � SpecifierSet�InvalidSpecifierr� r� s r �_process_requires_pythonz#_Validator._process_requires_pythong se � � � �*�5�1�1� 1���*� � � ��(�(��5�5�5�S� )� � � ����� ���s � �A�?�A� list[requirements.Requirement]c �� � g } |D ])}|� t j |� � � � �* |S # t j $ r }| � |�d�|�� � �d }~ww xY wr� )r� r � Requirement�InvalidRequirementr� )r r� �reqs�reqr� s r �_process_requires_distz!_Validator._process_requires_disto s� � � �� � � ;� ;��� � �L� 4�S� 9� 9�:�:�:�:� ;� �K�� �.� Y� Y� Y��(�(�C�)L�)L�)L�TW�(�X�X� X����� Y���s �,3 �A!�A � A!)r� r� r r )r� r� r2 r r r )r� r� r� r� r r r )ri r r� r� r r* )r� r r r� )r� r r r )r� r r r� )r� r3 r r3 )r� r3 r r� )r� r r r� )r� r3 r r )r" r$ r% r& r' r r� r� r� r� r� r� r� r� r� r� r� r r( r r r� r� � s^ � � � � � � �� � �I�I�I��M�M�M����� #(�� � � � � �4� 4� 4� 4� � � � �8 37�� � � � �-� -� -� -� � � � �� � � �� � � � � � � �@+� +� +� +� $� $� $� $� � � � � � � � � � r r� c � � e Zd ZU dZded< edd�d8d �� � Zedd�d9d �� � Z e� � Z d ed< e� � Z ded< e� � Z ded< ed�� � Z ded< e� � Z ded< ed�� � Zded< e� � Zded< e� � Zded < ed �� � Zded < e� � Zded < e� � Zded < ed�� � Zded!< e� � Zded"< e� � Zded#< ed$�� � Zded%< ed$�� � Zded&< e� � Zded'< ed�� � Zded(< ed$�� � Zd)ed*< ed$�� � Z d+ed,< ed$�� � Z ded-< ed$�� � Z d.ed/< ed �� � Z d0ed1< ed$�� � Z ded2< ed$�� � Z!ded3< ed�� � Z"ded4< ed�� � Z#ded5< ed�� � Z$ded6< d7S ):r� aJ Representation of distribution metadata. Compared to :class:`RawMetadata`, this class provides objects representing metadata fields instead of only using built-in types. Any invalid metadata will cause :exc:`InvalidMetadata` to be raised (with a :py:attr:`~BaseException.__cause__` attribute as appropriate). r0 r� Tr� rO r� �boolr c �& � | � � }|� � � |_ |�rjg } |j }t � |� � }n.# t $ r!}|� |� � d}Y d}~nd}~ww xY wt |j � � t z }|dhz }|D ]�} |r� | j | j } n8# t $ r+ t | d| ��� � } |� | � � Y �Mw xY wt � | � � } | |k r3t | } t | d� � } |� | � � ��t || � � ��# t $ r } |� | � � Y d} ~ ��d} ~ ww xY w|rt d|� � �|S )z�Create an instance from :class:`RawMetadata`. If *validate* is true, all metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. Nr1 �unrecognized field: zW{field} introduced in metadata version {field_metadata_version}, not {metadata_version}zinvalid metadata)�copyr� r1 r� �indexr* r� r� r� r� r� rb r� r� r )�clsrO r� �insr r1 � metadata_age�metadata_version_exc�fields_to_check�key�field_metadata_versionr� � field_ager+ s r �from_rawzMetadata.from_raw� s � � �c�e�e���9�9�;�;��� � + E�*,�J� (�#&�#7� � 7� =� =�>N� O� O� � ��"� (� (� (��!�!�"6�7�7�7�#'� � � � � � ����� (���� (��� 1� 1�O� C�O� � 2� 3� 3�O�&� +� +��+�'� %�%�58�\�#�5F�5L� 2� 2�� '� %� %� %�"1�#�7U�c�7U�7U�"V�"V�C� &� -� -�c� 2� 2� 2� $�H�%���� %=�$B�$B� 2�%� %� � %�|�3�3�$9�#�$>�E�"1� %�!S�# � # �C� '� -� -�c� 2� 2� 2� $��C��%�%�%�%��&� +� +� +� �%�%�c�*�*�*�*�*�*�*�*�����+���� � E�$�%7��D�D�D�� sZ �!A � A7�A2�2A7�!E�$B7�6E�72C,�)E�+C,�,AE�E� E<� E7�7E<rl c �J � t |� � \ }}|rPg }|D ]9}|t v r|�d�}nd|��}|� t ||� � � � �:|rt d|� � � | � ||�� � S # t $ r}t d|j � � d�d}~ww xY w)z�Parse metadata from email headers. If *validate* is true, the metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. z has invalid datar r� r� z invalid or unparsed metadataN)r� r� r� r* r r r ) r rO r� r~ r� r � unparsed_keyr � exc_groups r � from_emailzMetadata.from_email� s� � � $�D�)�)� ��X� � =�*,�J� (� J� J� � �#8�8�8�!-� B� B� B�G�G� E�\� E� E�G��!�!�/�,��"H�"H�I�I�I�I�� =�$�Z��<�<�<� ��<�<��h�<�7�7� 7�� � � � � �.� �0D�� �� ����� ���s �&A= �= B"�B � B"z _Validator[_MetadataVersion]r1 z_Validator[str]r2 z"_Validator[version_module.Version]r r� r� z _Validator[list[str] | None]rM r4 r� r< z_Validator[str | None]r5 r6 r� rK r7 r8 r= r9 r: r� rB rC r; r> z1_Validator[list[requirements.Requirement] | None]rD z*_Validator[specifiers.SpecifierSet | None]rG rH z!_Validator[dict[str, str] | None]rJ z-_Validator[list[utils.NormalizedName] | None]rL rE rF r? r@ rA N)rO r0 r� r r r� )rO rl r� r r r� )%r" r$ r% r& r' � classmethodr r r� r1 r2 r rM r4 r< r5 r6 rK r7 r8 r= r9 r: rB rC r; r> rD rG rH rJ rL rE rF r? r@ rA r( r r r� r� } s2 � � � � � � �� � �����=A� 6� 6� 6� 6� 6� �[�6�p �?C� � � � � � �[��6 6@�Z�\�\��A�A�A�A�<� &�J�L�L�D�(�(�(�(� � 3=�*�,�,�G�>�>�>�>�:�,6�J��-� -� -�G� � � � �D�.8�j�l�l�I�:�:�:�:�0�8B� ��8O�8O�8O��O�O�O�O�:�&0�j�l�l�G�2�2�2�2�R�*4�*�,�,�K�6�6�6�6�3�7A�z��7N�7N�7N� �N�N�N�N�L�-7�Z�\�\�H�9�9�9�9�0�(2� � � �I�4�4�4�4�1�+5�:�E�+B�+B�+B�L�B�B�B�B�4�%/�Z�\�\�F�1�1�1�1�.�+5�:�<�<�L�7�7�7�7�4�)3��%�)@�)@�)@�J�@�@�@�@�2�/9�z��/F�/F�/F��F�F�F�F�8�&0�j�l�l�G�2�2�2�2�/�0:� ��0G�0G�0G�K�G�G�G�G�2�GQ�z��H� H� H�M� � � � � 6�BL�*��C� C� C�O� � � � � 8� 7A�j�u�6M�6M�6M��M�M�M�M�9�6@�j�u�6M�6M�6M�L�M�M�M�M�3� EO�J��E� E� E�N� � � � � 7�2<�*�5�2I�2I�2I�M�I�I�I�I�5�3=�:�E�3J�3J�3J�N�J�J�J�J�6�-7�Z�e�-D�-D�-D�H�D�D�D�D�#�-7�Z�e�-D�-D�-D�H�D�D�D�D�#�.8�j�u�.E�.E�.E�I�E�E�E�E�$�$r r� )rO r r r3 )rO r3 r rI )ri rj rk rl r r )rO rl r r� )/� __future__r �email.feedparserr} � email.header� email.message� email.parser� email.policy�typingr r r r r r r] r r r r r� �TypeVarr r � NameError� Exceptionru r* r0 r� r� � _DICT_FIELDSrY rh rx r� �itemsr� r� �object� _NOT_FOUNDr� r� r� r� r� r� r( r r �<module>r) s �� "� "� "� "� "� "� � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � .� -� -� -� -� -� -� -� -� -� '� '� '� '� '� '��F�N�3����$��N�* $�N�N��) � W� W� W�W� W� W� W� W�� W� W� W� W� W�W����."� "� "� "� "�j� "� "� "� =� =� =� =� =�)�5� =� =� =� =�H� � ��" � � � � �� � 0� 0� 0� 0� %� %� %� %�P?� ?� ?� ?�: � �h� ��N� � �-� � �=� � � :� � �N� � �y� � �� � � � � �y� � �,� � �*� � �*� � �F� � �� � �&�! �" � �# �$ "��$�&��$�,�(��/��9 � � � �< U�T�6K�6Q�6Q�6S�6S�T�T�T� �m,� m,� m,� m,�` �V�X�X� � F�E�E� ��C�D� ��)� C� C� C�D�D��l� l� l� l� l���� l� l� l�^g%� g%� g%� g%� g%� g%� g%� g%� g%� g%s �A �A+�*A+ _manylinux.py 0000644 00000022562 15004414131 0007301 0 ustar 00 from __future__ import annotations import collections import contextlib import functools import os import re import sys import warnings from typing import Generator, Iterator, NamedTuple, Sequence from ._elffile import EIClass, EIData, ELFFile, EMachine EF_ARM_ABIMASK = 0xFF000000 EF_ARM_ABI_VER5 = 0x05000000 EF_ARM_ABI_FLOAT_HARD = 0x00000400 # `os.PathLike` not a generic type until Python 3.9, so sticking with `str` # as the type for `path` until then. @contextlib.contextmanager def _parse_elf(path: str) -> Generator[ELFFile | None, None, None]: try: with open(path, "rb") as f: yield ELFFile(f) except (OSError, TypeError, ValueError): yield None def _is_linux_armhf(executable: str) -> bool: # hard-float ABI can be detected from the ELF header of the running # process # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf with _parse_elf(executable) as f: return ( f is not None and f.capacity == EIClass.C32 and f.encoding == EIData.Lsb and f.machine == EMachine.Arm and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5 and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD ) def _is_linux_i686(executable: str) -> bool: with _parse_elf(executable) as f: return ( f is not None and f.capacity == EIClass.C32 and f.encoding == EIData.Lsb and f.machine == EMachine.I386 ) def _have_compatible_abi(executable: str, archs: Sequence[str]) -> bool: if "armv7l" in archs: return _is_linux_armhf(executable) if "i686" in archs: return _is_linux_i686(executable) allowed_archs = { "x86_64", "aarch64", "ppc64", "ppc64le", "s390x", "loongarch64", "riscv64", } return any(arch in allowed_archs for arch in archs) # If glibc ever changes its major version, we need to know what the last # minor version was, so we can build the complete list of all versions. # For now, guess what the highest minor version might be, assume it will # be 50 for testing. Once this actually happens, update the dictionary # with the actual value. _LAST_GLIBC_MINOR: dict[int, int] = collections.defaultdict(lambda: 50) class _GLibCVersion(NamedTuple): major: int minor: int def _glibc_version_string_confstr() -> str | None: """ Primary implementation of glibc_version_string using os.confstr. """ # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely # to be broken or missing. This strategy is used in the standard library # platform module. # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 try: # Should be a string like "glibc 2.17". version_string: str | None = os.confstr("CS_GNU_LIBC_VERSION") assert version_string is not None _, version = version_string.rsplit() except (AssertionError, AttributeError, OSError, ValueError): # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... return None return version def _glibc_version_string_ctypes() -> str | None: """ Fallback implementation of glibc_version_string using ctypes. """ try: import ctypes except ImportError: return None # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen # manpage says, "If filename is NULL, then the returned handle is for the # main program". This way we can let the linker do the work to figure out # which libc our process is actually using. # # We must also handle the special case where the executable is not a # dynamically linked executable. This can occur when using musl libc, # for example. In this situation, dlopen() will error, leading to an # OSError. Interestingly, at least in the case of musl, there is no # errno set on the OSError. The single string argument used to construct # OSError comes from libc itself and is therefore not portable to # hard code here. In any case, failure to call dlopen() means we # can proceed, so we bail on our attempt. try: process_namespace = ctypes.CDLL(None) except OSError: return None try: gnu_get_libc_version = process_namespace.gnu_get_libc_version except AttributeError: # Symbol doesn't exist -> therefore, we are not linked to # glibc. return None # Call gnu_get_libc_version, which returns a string like "2.5" gnu_get_libc_version.restype = ctypes.c_char_p version_str: str = gnu_get_libc_version() # py2 / py3 compatibility: if not isinstance(version_str, str): version_str = version_str.decode("ascii") return version_str def _glibc_version_string() -> str | None: """Returns glibc version string, or None if not using glibc.""" return _glibc_version_string_confstr() or _glibc_version_string_ctypes() def _parse_glibc_version(version_str: str) -> tuple[int, int]: """Parse glibc version. We use a regexp instead of str.split because we want to discard any random junk that might come after the minor version -- this might happen in patched/forked versions of glibc (e.g. Linaro's version of glibc uses version strings like "2.20-2014.11"). See gh-3588. """ m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str) if not m: warnings.warn( f"Expected glibc version with 2 components major.minor," f" got: {version_str}", RuntimeWarning, ) return -1, -1 return int(m.group("major")), int(m.group("minor")) @functools.lru_cache def _get_glibc_version() -> tuple[int, int]: version_str = _glibc_version_string() if version_str is None: return (-1, -1) return _parse_glibc_version(version_str) # From PEP 513, PEP 600 def _is_compatible(arch: str, version: _GLibCVersion) -> bool: sys_glibc = _get_glibc_version() if sys_glibc < version: return False # Check for presence of _manylinux module. try: import _manylinux except ImportError: return True if hasattr(_manylinux, "manylinux_compatible"): result = _manylinux.manylinux_compatible(version[0], version[1], arch) if result is not None: return bool(result) return True if version == _GLibCVersion(2, 5): if hasattr(_manylinux, "manylinux1_compatible"): return bool(_manylinux.manylinux1_compatible) if version == _GLibCVersion(2, 12): if hasattr(_manylinux, "manylinux2010_compatible"): return bool(_manylinux.manylinux2010_compatible) if version == _GLibCVersion(2, 17): if hasattr(_manylinux, "manylinux2014_compatible"): return bool(_manylinux.manylinux2014_compatible) return True _LEGACY_MANYLINUX_MAP = { # CentOS 7 w/ glibc 2.17 (PEP 599) (2, 17): "manylinux2014", # CentOS 6 w/ glibc 2.12 (PEP 571) (2, 12): "manylinux2010", # CentOS 5 w/ glibc 2.5 (PEP 513) (2, 5): "manylinux1", } def platform_tags(archs: Sequence[str]) -> Iterator[str]: """Generate manylinux tags compatible to the current platform. :param archs: Sequence of compatible architectures. The first one shall be the closest to the actual architecture and be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be manylinux-compatible. :returns: An iterator of compatible manylinux tags. """ if not _have_compatible_abi(sys.executable, archs): return # Oldest glibc to be supported regardless of architecture is (2, 17). too_old_glibc2 = _GLibCVersion(2, 16) if set(archs) & {"x86_64", "i686"}: # On x86/i686 also oldest glibc to be supported is (2, 5). too_old_glibc2 = _GLibCVersion(2, 4) current_glibc = _GLibCVersion(*_get_glibc_version()) glibc_max_list = [current_glibc] # We can assume compatibility across glibc major versions. # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 # # Build a list of maximum glibc versions so that we can # output the canonical list of all glibc from current_glibc # down to too_old_glibc2, including all intermediary versions. for glibc_major in range(current_glibc.major - 1, 1, -1): glibc_minor = _LAST_GLIBC_MINOR[glibc_major] glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) for arch in archs: for glibc_max in glibc_max_list: if glibc_max.major == too_old_glibc2.major: min_minor = too_old_glibc2.minor else: # For other glibc major versions oldest supported is (x, 0). min_minor = -1 for glibc_minor in range(glibc_max.minor, min_minor, -1): glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) tag = "manylinux_{}_{}".format(*glibc_version) if _is_compatible(arch, glibc_version): yield f"{tag}_{arch}" # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. if glibc_version in _LEGACY_MANYLINUX_MAP: legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version] if _is_compatible(arch, glibc_version): yield f"{legacy_tag}_{arch}" _musllinux.py 0000644 00000005206 15004414131 0007311 0 ustar 00 """PEP 656 support. This module implements logic to detect if the currently running Python is linked against musl, and what musl version is used. """ from __future__ import annotations import functools import re import subprocess import sys from typing import Iterator, NamedTuple, Sequence from ._elffile import ELFFile class _MuslVersion(NamedTuple): major: int minor: int def _parse_musl_version(output: str) -> _MuslVersion | None: lines = [n for n in (n.strip() for n in output.splitlines()) if n] if len(lines) < 2 or lines[0][:4] != "musl": return None m = re.match(r"Version (\d+)\.(\d+)", lines[1]) if not m: return None return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) @functools.lru_cache def _get_musl_version(executable: str) -> _MuslVersion | None: """Detect currently-running musl runtime version. This is done by checking the specified executable's dynamic linking information, and invoking the loader to parse its output for a version string. If the loader is musl, the output would be something like:: musl libc (x86_64) Version 1.2.2 Dynamic Program Loader """ try: with open(executable, "rb") as f: ld = ELFFile(f).interpreter except (OSError, TypeError, ValueError): return None if ld is None or "musl" not in ld: return None proc = subprocess.run([ld], stderr=subprocess.PIPE, text=True) return _parse_musl_version(proc.stderr) def platform_tags(archs: Sequence[str]) -> Iterator[str]: """Generate musllinux tags compatible to the current platform. :param archs: Sequence of compatible architectures. The first one shall be the closest to the actual architecture and be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be musllinux-compatible. :returns: An iterator of compatible musllinux tags. """ sys_musl = _get_musl_version(sys.executable) if sys_musl is None: # Python not dynamically linked against musl. return for arch in archs: for minor in range(sys_musl.minor, -1, -1): yield f"musllinux_{sys_musl.major}_{minor}_{arch}" if __name__ == "__main__": # pragma: no cover import sysconfig plat = sysconfig.get_platform() assert plat.startswith("linux-"), "not linux" print("plat:", plat) print("musl:", _get_musl_version(sys.executable)) print("tags:", end=" ") for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): print(t, end="\n ") _structures.py 0000644 00000002627 15004414131 0007500 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. class InfinityType: def __repr__(self) -> str: return "Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return False def __le__(self, other: object) -> bool: return False def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return True def __ge__(self, other: object) -> bool: return True def __neg__(self: object) -> "NegativeInfinityType": return NegativeInfinity Infinity = InfinityType() class NegativeInfinityType: def __repr__(self) -> str: return "-Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return True def __le__(self, other: object) -> bool: return True def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return False def __ge__(self, other: object) -> bool: return False def __neg__(self: object) -> InfinityType: return Infinity NegativeInfinity = NegativeInfinityType() markers.py 0000644 00000024657 15004414131 0006571 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations import operator import os import platform import sys from typing import Any, Callable, TypedDict, cast from ._parser import MarkerAtom, MarkerList, Op, Value, Variable from ._parser import parse_marker as _parse_marker from ._tokenizer import ParserSyntaxError from .specifiers import InvalidSpecifier, Specifier from .utils import canonicalize_name __all__ = [ "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName", "Marker", "default_environment", ] Operator = Callable[[str, str], bool] class InvalidMarker(ValueError): """ An invalid marker was found, users should refer to PEP 508. """ class UndefinedComparison(ValueError): """ An invalid operation was attempted on a value that doesn't support it. """ class UndefinedEnvironmentName(ValueError): """ A name was attempted to be used that does not exist inside of the environment. """ class Environment(TypedDict): implementation_name: str """The implementation's identifier, e.g. ``'cpython'``.""" implementation_version: str """ The implementation's version, e.g. ``'3.13.0a2'`` for CPython 3.13.0a2, or ``'7.3.13'`` for PyPy3.10 v7.3.13. """ os_name: str """ The value of :py:data:`os.name`. The name of the operating system dependent module imported, e.g. ``'posix'``. """ platform_machine: str """ Returns the machine type, e.g. ``'i386'``. An empty string if the value cannot be determined. """ platform_release: str """ The system's release, e.g. ``'2.2.0'`` or ``'NT'``. An empty string if the value cannot be determined. """ platform_system: str """ The system/OS name, e.g. ``'Linux'``, ``'Windows'`` or ``'Java'``. An empty string if the value cannot be determined. """ platform_version: str """ The system's release version, e.g. ``'#3 on degas'``. An empty string if the value cannot be determined. """ python_full_version: str """ The Python version as string ``'major.minor.patchlevel'``. Note that unlike the Python :py:data:`sys.version`, this value will always include the patchlevel (it defaults to 0). """ platform_python_implementation: str """ A string identifying the Python implementation, e.g. ``'CPython'``. """ python_version: str """The Python version as string ``'major.minor'``.""" sys_platform: str """ This string contains a platform identifier that can be used to append platform-specific components to :py:data:`sys.path`, for instance. For Unix systems, except on Linux and AIX, this is the lowercased OS name as returned by ``uname -s`` with the first part of the version as returned by ``uname -r`` appended, e.g. ``'sunos5'`` or ``'freebsd8'``, at the time when Python was built. """ def _normalize_extra_values(results: Any) -> Any: """ Normalize extra values. """ if isinstance(results[0], tuple): lhs, op, rhs = results[0] if isinstance(lhs, Variable) and lhs.value == "extra": normalized_extra = canonicalize_name(rhs.value) rhs = Value(normalized_extra) elif isinstance(rhs, Variable) and rhs.value == "extra": normalized_extra = canonicalize_name(lhs.value) lhs = Value(normalized_extra) results[0] = lhs, op, rhs return results def _format_marker( marker: list[str] | MarkerAtom | str, first: bool | None = True ) -> str: assert isinstance(marker, (list, tuple, str)) # Sometimes we have a structure like [[...]] which is a single item list # where the single item is itself it's own list. In that case we want skip # the rest of this function so that we don't get extraneous () on the # outside. if ( isinstance(marker, list) and len(marker) == 1 and isinstance(marker[0], (list, tuple)) ): return _format_marker(marker[0]) if isinstance(marker, list): inner = (_format_marker(m, first=False) for m in marker) if first: return " ".join(inner) else: return "(" + " ".join(inner) + ")" elif isinstance(marker, tuple): return " ".join([m.serialize() for m in marker]) else: return marker _operators: dict[str, Operator] = { "in": lambda lhs, rhs: lhs in rhs, "not in": lambda lhs, rhs: lhs not in rhs, "<": operator.lt, "<=": operator.le, "==": operator.eq, "!=": operator.ne, ">=": operator.ge, ">": operator.gt, } def _eval_op(lhs: str, op: Op, rhs: str) -> bool: try: spec = Specifier("".join([op.serialize(), rhs])) except InvalidSpecifier: pass else: return spec.contains(lhs, prereleases=True) oper: Operator | None = _operators.get(op.serialize()) if oper is None: raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") return oper(lhs, rhs) def _normalize(*values: str, key: str) -> tuple[str, ...]: # PEP 685 – Comparison of extra names for optional distribution dependencies # https://peps.python.org/pep-0685/ # > When comparing extra names, tools MUST normalize the names being # > compared using the semantics outlined in PEP 503 for names if key == "extra": return tuple(canonicalize_name(v) for v in values) # other environment markers don't have such standards return values def _evaluate_markers(markers: MarkerList, environment: dict[str, str]) -> bool: groups: list[list[bool]] = [[]] for marker in markers: assert isinstance(marker, (list, tuple, str)) if isinstance(marker, list): groups[-1].append(_evaluate_markers(marker, environment)) elif isinstance(marker, tuple): lhs, op, rhs = marker if isinstance(lhs, Variable): environment_key = lhs.value lhs_value = environment[environment_key] rhs_value = rhs.value else: lhs_value = lhs.value environment_key = rhs.value rhs_value = environment[environment_key] lhs_value, rhs_value = _normalize(lhs_value, rhs_value, key=environment_key) groups[-1].append(_eval_op(lhs_value, op, rhs_value)) else: assert marker in ["and", "or"] if marker == "or": groups.append([]) return any(all(item) for item in groups) def format_full_version(info: sys._version_info) -> str: version = "{0.major}.{0.minor}.{0.micro}".format(info) kind = info.releaselevel if kind != "final": version += kind[0] + str(info.serial) return version def default_environment() -> Environment: iver = format_full_version(sys.implementation.version) implementation_name = sys.implementation.name return { "implementation_name": implementation_name, "implementation_version": iver, "os_name": os.name, "platform_machine": platform.machine(), "platform_release": platform.release(), "platform_system": platform.system(), "platform_version": platform.version(), "python_full_version": platform.python_version(), "platform_python_implementation": platform.python_implementation(), "python_version": ".".join(platform.python_version_tuple()[:2]), "sys_platform": sys.platform, } class Marker: def __init__(self, marker: str) -> None: # Note: We create a Marker object without calling this constructor in # packaging.requirements.Requirement. If any additional logic is # added here, make sure to mirror/adapt Requirement. try: self._markers = _normalize_extra_values(_parse_marker(marker)) # The attribute `_markers` can be described in terms of a recursive type: # MarkerList = List[Union[Tuple[Node, ...], str, MarkerList]] # # For example, the following expression: # python_version > "3.6" or (python_version == "3.6" and os_name == "unix") # # is parsed into: # [ # (<Variable('python_version')>, <Op('>')>, <Value('3.6')>), # 'and', # [ # (<Variable('python_version')>, <Op('==')>, <Value('3.6')>), # 'or', # (<Variable('os_name')>, <Op('==')>, <Value('unix')>) # ] # ] except ParserSyntaxError as e: raise InvalidMarker(str(e)) from e def __str__(self) -> str: return _format_marker(self._markers) def __repr__(self) -> str: return f"<Marker('{self}')>" def __hash__(self) -> int: return hash((self.__class__.__name__, str(self))) def __eq__(self, other: Any) -> bool: if not isinstance(other, Marker): return NotImplemented return str(self) == str(other) def evaluate(self, environment: dict[str, str] | None = None) -> bool: """Evaluate a marker. Return the boolean from evaluating the given marker against the environment. environment is an optional argument to override all or part of the determined environment. The environment is determined from the current Python process. """ current_environment = cast("dict[str, str]", default_environment()) current_environment["extra"] = "" # Work around platform.python_version() returning something that is not PEP 440 # compliant for non-tagged Python builds. We preserve default_environment()'s # behavior of returning platform.python_version() verbatim, and leave it to the # caller to provide a syntactically valid version if they want to override it. if current_environment["python_full_version"].endswith("+"): current_environment["python_full_version"] += "local" if environment is not None: current_environment.update(environment) # The API used to allow setting extra to None. We need to handle this # case for backwards compatibility. if current_environment["extra"] is None: current_environment["extra"] = "" return _evaluate_markers(self._markers, current_environment) requirements.py 0000644 00000005603 15004414131 0007636 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations from typing import Any, Iterator from ._parser import parse_requirement as _parse_requirement from ._tokenizer import ParserSyntaxError from .markers import Marker, _normalize_extra_values from .specifiers import SpecifierSet from .utils import canonicalize_name class InvalidRequirement(ValueError): """ An invalid requirement was found, users should refer to PEP 508. """ class Requirement: """Parse a requirement. Parse a given requirement string into its parts, such as name, specifier, URL, and extras. Raises InvalidRequirement on a badly-formed requirement string. """ # TODO: Can we test whether something is contained within a requirement? # If so how do we do that? Do we need to test against the _name_ of # the thing as well as the version? What about the markers? # TODO: Can we normalize the name and extra name? def __init__(self, requirement_string: str) -> None: try: parsed = _parse_requirement(requirement_string) except ParserSyntaxError as e: raise InvalidRequirement(str(e)) from e self.name: str = parsed.name self.url: str | None = parsed.url or None self.extras: set[str] = set(parsed.extras or []) self.specifier: SpecifierSet = SpecifierSet(parsed.specifier) self.marker: Marker | None = None if parsed.marker is not None: self.marker = Marker.__new__(Marker) self.marker._markers = _normalize_extra_values(parsed.marker) def _iter_parts(self, name: str) -> Iterator[str]: yield name if self.extras: formatted_extras = ",".join(sorted(self.extras)) yield f"[{formatted_extras}]" if self.specifier: yield str(self.specifier) if self.url: yield f"@ {self.url}" if self.marker: yield " " if self.marker: yield f"; {self.marker}" def __str__(self) -> str: return "".join(self._iter_parts(self.name)) def __repr__(self) -> str: return f"<Requirement('{self}')>" def __hash__(self) -> int: return hash( ( self.__class__.__name__, *self._iter_parts(canonicalize_name(self.name)), ) ) def __eq__(self, other: Any) -> bool: if not isinstance(other, Requirement): return NotImplemented return ( canonicalize_name(self.name) == canonicalize_name(other.name) and self.extras == other.extras and self.specifier == other.specifier and self.url == other.url and self.marker == other.marker ) specifiers.py 0000644 00000115472 15004414131 0007255 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. """ .. testsetup:: from pip._vendor.packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from pip._vendor.packaging.version import Version """ from __future__ import annotations import abc import itertools import re from typing import Callable, Iterable, Iterator, TypeVar, Union from .utils import canonicalize_version from .version import Version UnparsedVersion = Union[Version, str] UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion) CallableOperator = Callable[[Version, str], bool] def _coerce_version(version: UnparsedVersion) -> Version: if not isinstance(version, Version): version = Version(version) return version class InvalidSpecifier(ValueError): """ Raised when attempting to create a :class:`Specifier` with a specifier string that is invalid. >>> Specifier("lolwat") Traceback (most recent call last): ... packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' """ class BaseSpecifier(metaclass=abc.ABCMeta): @abc.abstractmethod def __str__(self) -> str: """ Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. """ @abc.abstractmethod def __hash__(self) -> int: """ Returns a hash value for this Specifier-like object. """ @abc.abstractmethod def __eq__(self, other: object) -> bool: """ Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. """ @property @abc.abstractmethod def prereleases(self) -> bool | None: """Whether or not pre-releases as a whole are allowed. This can be set to either ``True`` or ``False`` to explicitly enable or disable prereleases or it can be set to ``None`` (the default) to use default semantics. """ @prereleases.setter def prereleases(self, value: bool) -> None: """Setter for :attr:`prereleases`. :param value: The value to set. """ @abc.abstractmethod def contains(self, item: str, prereleases: bool | None = None) -> bool: """ Determines if the given item is contained within this specifier. """ @abc.abstractmethod def filter( self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None ) -> Iterator[UnparsedVersionVar]: """ Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. """ class Specifier(BaseSpecifier): """This class abstracts handling of version specifiers. .. tip:: It is generally not required to instantiate this manually. You should instead prefer to work with :class:`SpecifierSet` instead, which can parse comma-separated version specifiers (which is what package metadata contains). """ _operator_regex_str = r""" (?P<operator>(~=|==|!=|<=|>=|<|>|===)) """ _version_regex_str = r""" (?P<version> (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. (?<====) # Only match for the identity operator \s* [^\s;)]* # The arbitrary version can be just about anything, # we match everything except for whitespace, a # semi-colon for marker support, and a closing paren # since versions can be enclosed in them. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?<===|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release # You cannot use a wild card and a pre-release, post-release, a dev or # local version together so group them with a | and make them optional. (?: \.\* # Wild card syntax of .* | (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?<=~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?<!==|!=|~=) # We have special cases for these # operators so we want to make sure they # don't match here. \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) ) """ _regex = re.compile( r"^\s*" + _operator_regex_str + _version_regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE, ) _operators = { "~=": "compatible", "==": "equal", "!=": "not_equal", "<=": "less_than_equal", ">=": "greater_than_equal", "<": "less_than", ">": "greater_than", "===": "arbitrary", } def __init__(self, spec: str = "", prereleases: bool | None = None) -> None: """Initialize a Specifier instance. :param spec: The string representation of a specifier which will be parsed and normalized before use. :param prereleases: This tells the specifier if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given specifier is invalid (i.e. bad syntax). """ match = self._regex.search(spec) if not match: raise InvalidSpecifier(f"Invalid specifier: '{spec}'") self._spec: tuple[str, str] = ( match.group("operator").strip(), match.group("version").strip(), ) # Store whether or not this Specifier should accept prereleases self._prereleases = prereleases # https://github.com/python/mypy/pull/13475#pullrequestreview-1079784515 @property # type: ignore[override] def prereleases(self) -> bool: # If there is an explicit prereleases set for this, then we'll just # blindly use that. if self._prereleases is not None: return self._prereleases # Look at all of our specifiers and determine if they are inclusive # operators, and if they are if they are including an explicit # prerelease. operator, version = self._spec if operator in ["==", ">=", "<=", "~=", "==="]: # The == specifier can include a trailing .*, if it does we # want to remove before parsing. if operator == "==" and version.endswith(".*"): version = version[:-2] # Parse the version, and if it is a pre-release than this # specifier allows pre-releases. if Version(version).is_prerelease: return True return False @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value @property def operator(self) -> str: """The operator of this specifier. >>> Specifier("==1.2.3").operator '==' """ return self._spec[0] @property def version(self) -> str: """The version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' """ return self._spec[1] def __repr__(self) -> str: """A representation of the Specifier that shows all internal state. >>> Specifier('>=1.0.0') <Specifier('>=1.0.0')> >>> Specifier('>=1.0.0', prereleases=False) <Specifier('>=1.0.0', prereleases=False)> >>> Specifier('>=1.0.0', prereleases=True) <Specifier('>=1.0.0', prereleases=True)> """ pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return f"<{self.__class__.__name__}({str(self)!r}{pre})>" def __str__(self) -> str: """A string representation of the Specifier that can be round-tripped. >>> str(Specifier('>=1.0.0')) '>=1.0.0' >>> str(Specifier('>=1.0.0', prereleases=False)) '>=1.0.0' """ return "{}{}".format(*self._spec) @property def _canonical_spec(self) -> tuple[str, str]: canonical_version = canonicalize_version( self._spec[1], strip_trailing_zero=(self._spec[0] != "~="), ) return self._spec[0], canonical_version def __hash__(self) -> int: return hash(self._canonical_spec) def __eq__(self, other: object) -> bool: """Whether or not the two Specifier-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") True >>> (Specifier("==1.2.3", prereleases=False) == ... Specifier("==1.2.3", prereleases=True)) True >>> Specifier("==1.2.3") == "==1.2.3" True >>> Specifier("==1.2.3") == Specifier("==1.2.4") False >>> Specifier("==1.2.3") == Specifier("~=1.2.3") False """ if isinstance(other, str): try: other = self.__class__(str(other)) except InvalidSpecifier: return NotImplemented elif not isinstance(other, self.__class__): return NotImplemented return self._canonical_spec == other._canonical_spec def _get_operator(self, op: str) -> CallableOperator: operator_callable: CallableOperator = getattr( self, f"_compare_{self._operators[op]}" ) return operator_callable def _compare_compatible(self, prospective: Version, spec: str) -> bool: # Compatible releases have an equivalent combination of >= and ==. That # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to # implement this in terms of the other specifiers instead of # implementing it ourselves. The only thing we need to do is construct # the other specifiers. # We want everything but the last item in the version, but we want to # ignore suffix segments. prefix = _version_join( list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] ) # Add the prefix notation to the end of our string prefix += ".*" return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( prospective, prefix ) def _compare_equal(self, prospective: Version, spec: str) -> bool: # We need special logic to handle prefix matching if spec.endswith(".*"): # In the case of prefix matching we want to ignore local segment. normalized_prospective = canonicalize_version( prospective.public, strip_trailing_zero=False ) # Get the normalized version string ignoring the trailing .* normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False) # Split the spec out by bangs and dots, and pretend that there is # an implicit dot in between a release segment and a pre-release segment. split_spec = _version_split(normalized_spec) # Split the prospective version out by bangs and dots, and pretend # that there is an implicit dot in between a release segment and # a pre-release segment. split_prospective = _version_split(normalized_prospective) # 0-pad the prospective version before shortening it to get the correct # shortened version. padded_prospective, _ = _pad_version(split_prospective, split_spec) # Shorten the prospective version to be the same length as the spec # so that we can determine if the specifier is a prefix of the # prospective version or not. shortened_prospective = padded_prospective[: len(split_spec)] return shortened_prospective == split_spec else: # Convert our spec string into a Version spec_version = Version(spec) # If the specifier does not have a local segment, then we want to # act as if the prospective version also does not have a local # segment. if not spec_version.local: prospective = Version(prospective.public) return prospective == spec_version def _compare_not_equal(self, prospective: Version, spec: str) -> bool: return not self._compare_equal(prospective, spec) def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) <= Version(spec) def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) >= Version(spec) def _compare_less_than(self, prospective: Version, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is less than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective < spec: return False # This special case is here so that, unless the specifier itself # includes is a pre-release version, that we do not accept pre-release # versions for the version mentioned in the specifier (e.g. <3.1 should # not match 3.1.dev0, but should match 3.0.dev0). if not spec.is_prerelease and prospective.is_prerelease: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # less than the spec version *and* it's not a pre-release of the same # version in the spec. return True def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is greater than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective > spec: return False # This special case is here so that, unless the specifier itself # includes is a post-release version, that we do not accept # post-release versions for the version mentioned in the specifier # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). if not spec.is_postrelease and prospective.is_postrelease: if Version(prospective.base_version) == Version(spec.base_version): return False # Ensure that we do not allow a local version of the version mentioned # in the specifier, which is technically greater than, to match. if prospective.local is not None: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # greater than the spec version *and* it's not a pre-release of the # same version in the spec. return True def _compare_arbitrary(self, prospective: Version, spec: str) -> bool: return str(prospective).lower() == str(spec).lower() def __contains__(self, item: str | Version) -> bool: """Return whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in Specifier(">=1.2.3") True >>> Version("1.2.3") in Specifier(">=1.2.3") True >>> "1.0.0" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True """ return self.contains(item) def contains(self, item: UnparsedVersion, prereleases: bool | None = None) -> bool: """Return whether or not the item is contained in this specifier. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this Specifier. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> Specifier(">=1.2.3").contains("1.2.3") True >>> Specifier(">=1.2.3").contains(Version("1.2.3")) True >>> Specifier(">=1.2.3").contains("1.0.0") False >>> Specifier(">=1.2.3").contains("1.3.0a1") False >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") True >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) True """ # Determine if prereleases are to be allowed or not. if prereleases is None: prereleases = self.prereleases # Normalize item to a Version, this allows us to have a shortcut for # "2.0" in Specifier(">=2") normalized_item = _coerce_version(item) # Determine if we should be supporting prereleases in this specifier # or not, if we do not support prereleases than we can short circuit # logic if this version is a prereleases. if normalized_item.is_prerelease and not prereleases: return False # Actually do the comparison to determine if this item is contained # within this Specifier or not. operator_callable: CallableOperator = self._get_operator(self.operator) return operator_callable(normalized_item, self.version) def filter( self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None ) -> Iterator[UnparsedVersionVar]: """Filter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(Specifier().contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) ['1.2.3', '1.3', <Version('1.4')>] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) ['1.5a1'] >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] """ yielded = False found_prereleases = [] kw = {"prereleases": prereleases if prereleases is not None else True} # Attempt to iterate over all the values in the iterable and if any of # them match, yield them. for version in iterable: parsed_version = _coerce_version(version) if self.contains(parsed_version, **kw): # If our version is a prerelease, and we were not set to allow # prereleases, then we'll store it for later in case nothing # else matches this specifier. if parsed_version.is_prerelease and not ( prereleases or self.prereleases ): found_prereleases.append(version) # Either this is not a prerelease, or we should have been # accepting prereleases from the beginning. else: yielded = True yield version # Now that we've iterated over everything, determine if we've yielded # any values, and if we have not and we have any prereleases stored up # then we will go ahead and yield the prereleases. if not yielded and found_prereleases: for version in found_prereleases: yield version _prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") def _version_split(version: str) -> list[str]: """Split version into components. The split components are intended for version comparison. The logic does not attempt to retain the original version string, so joining the components back with :func:`_version_join` may not produce the original version string. """ result: list[str] = [] epoch, _, rest = version.rpartition("!") result.append(epoch or "0") for item in rest.split("."): match = _prefix_regex.search(item) if match: result.extend(match.groups()) else: result.append(item) return result def _version_join(components: list[str]) -> str: """Join split version components into a version string. This function assumes the input came from :func:`_version_split`, where the first component must be the epoch (either empty or numeric), and all other components numeric. """ epoch, *rest = components return f"{epoch}!{'.'.join(rest)}" def _is_not_suffix(segment: str) -> bool: return not any( segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") ) def _pad_version(left: list[str], right: list[str]) -> tuple[list[str], list[str]]: left_split, right_split = [], [] # Get the release segment of our versions left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) # Get the rest of our versions left_split.append(left[len(left_split[0]) :]) right_split.append(right[len(right_split[0]) :]) # Insert our padding left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) return ( list(itertools.chain.from_iterable(left_split)), list(itertools.chain.from_iterable(right_split)), ) class SpecifierSet(BaseSpecifier): """This class abstracts handling of a set of version specifiers. It can be passed a single specifier (``>=3.0``), a comma-separated list of specifiers (``>=3.0,!=3.1``), or no specifier at all. """ def __init__(self, specifiers: str = "", prereleases: bool | None = None) -> None: """Initialize a SpecifierSet instance. :param specifiers: The string representation of a specifier or a comma-separated list of specifiers which will be parsed and normalized before use. :param prereleases: This tells the SpecifierSet if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given ``specifiers`` are not parseable than this exception will be raised. """ # Split on `,` to break each individual specifier into it's own item, and # strip each item to remove leading/trailing whitespace. split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] # Make each individual specifier a Specifier and save in a frozen set for later. self._specs = frozenset(map(Specifier, split_specifiers)) # Store our prereleases value so we can use it later to determine if # we accept prereleases or not. self._prereleases = prereleases @property def prereleases(self) -> bool | None: # If we have been given an explicit prerelease modifier, then we'll # pass that through here. if self._prereleases is not None: return self._prereleases # If we don't have any specifiers, and we don't have a forced value, # then we'll just return None since we don't know if this should have # pre-releases or not. if not self._specs: return None # Otherwise we'll see if any of the given specifiers accept # prereleases, if any of them do we'll return True, otherwise False. return any(s.prereleases for s in self._specs) @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value def __repr__(self) -> str: """A representation of the specifier set that shows all internal state. Note that the ordering of the individual specifiers within the set may not match the input string. >>> SpecifierSet('>=1.0.0,!=2.0.0') <SpecifierSet('!=2.0.0,>=1.0.0')> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) <SpecifierSet('!=2.0.0,>=1.0.0', prereleases=False)> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) <SpecifierSet('!=2.0.0,>=1.0.0', prereleases=True)> """ pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return f"<SpecifierSet({str(self)!r}{pre})>" def __str__(self) -> str: """A string representation of the specifier set that can be round-tripped. Note that the ordering of the individual specifiers within the set may not match the input string. >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) '!=1.0.1,>=1.0.0' >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) '!=1.0.1,>=1.0.0' """ return ",".join(sorted(str(s) for s in self._specs)) def __hash__(self) -> int: return hash(self._specs) def __and__(self, other: SpecifierSet | str) -> SpecifierSet: """Return a SpecifierSet which is a combination of the two sets. :param other: The other object to combine with. >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' <SpecifierSet('!=1.0.1,!=2.0.1,<=2.0.0,>=1.0.0')> >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') <SpecifierSet('!=1.0.1,!=2.0.1,<=2.0.0,>=1.0.0')> """ if isinstance(other, str): other = SpecifierSet(other) elif not isinstance(other, SpecifierSet): return NotImplemented specifier = SpecifierSet() specifier._specs = frozenset(self._specs | other._specs) if self._prereleases is None and other._prereleases is not None: specifier._prereleases = other._prereleases elif self._prereleases is not None and other._prereleases is None: specifier._prereleases = self._prereleases elif self._prereleases == other._prereleases: specifier._prereleases = self._prereleases else: raise ValueError( "Cannot combine SpecifierSets with True and False prerelease " "overrides." ) return specifier def __eq__(self, other: object) -> bool: """Whether or not the two SpecifierSet-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") True >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) True >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" True >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") False >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") False """ if isinstance(other, (str, Specifier)): other = SpecifierSet(str(other)) elif not isinstance(other, SpecifierSet): return NotImplemented return self._specs == other._specs def __len__(self) -> int: """Returns the number of specifiers in this specifier set.""" return len(self._specs) def __iter__(self) -> Iterator[Specifier]: """ Returns an iterator over all the underlying :class:`Specifier` instances in this specifier set. >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) [<Specifier('!=1.0.1')>, <Specifier('>=1.0.0')>] """ return iter(self._specs) def __contains__(self, item: UnparsedVersion) -> bool: """Return whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") True >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") True >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True """ return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: bool | None = None, installed: bool | None = None, ) -> bool: """Return whether or not the item is contained in this SpecifierSet. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this SpecifierSet. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") False >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True """ # Ensure that our item is a Version instance. if not isinstance(item, Version): item = Version(item) # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # We can determine if we're going to allow pre-releases by looking to # see if any of the underlying items supports them. If none of them do # and this item is a pre-release then we do not allow it and we can # short circuit that here. # Note: This means that 1.0.dev1 would not be contained in something # like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 if not prereleases and item.is_prerelease: return False if installed and item.is_prerelease: item = Version(item.base_version) # We simply dispatch to the underlying specs here to make sure that the # given version is contained within all of them. # Note: This use of all() here means that an empty set of specifiers # will always return True, this is an explicit design decision. return all(s.contains(item, prereleases=prereleases) for s in self._specs) def filter( self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None ) -> Iterator[UnparsedVersionVar]: """Filter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) ['1.3', <Version('1.4')>] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) [] >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] An "empty" SpecifierSet will filter items based on the presence of prerelease versions in the set. >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet("").filter(["1.5a1"])) ['1.5a1'] >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] """ # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # If we have any specifiers, then we want to wrap our iterable in the # filter method for each one, this will act as a logical AND amongst # each specifier. if self._specs: for spec in self._specs: iterable = spec.filter(iterable, prereleases=bool(prereleases)) return iter(iterable) # If we do not have any specifiers, then we need to have a rough filter # which will filter out any pre-releases, unless there are no final # releases. else: filtered: list[UnparsedVersionVar] = [] found_prereleases: list[UnparsedVersionVar] = [] for item in iterable: parsed_version = _coerce_version(item) # Store any item which is a pre-release for later unless we've # already found a final version or we are accepting prereleases if parsed_version.is_prerelease and not prereleases: if not filtered: found_prereleases.append(item) else: filtered.append(item) # If we've found no items except for pre-releases, then we'll go # ahead and use the pre-releases if not filtered and found_prereleases and prereleases is None: return iter(found_prereleases) return iter(filtered) tags.py 0000644 00000051614 15004414131 0006054 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations import logging import platform import re import struct import subprocess import sys import sysconfig from importlib.machinery import EXTENSION_SUFFIXES from typing import ( Iterable, Iterator, Sequence, Tuple, cast, ) from . import _manylinux, _musllinux logger = logging.getLogger(__name__) PythonVersion = Sequence[int] AppleVersion = Tuple[int, int] INTERPRETER_SHORT_NAMES: dict[str, str] = { "python": "py", # Generic. "cpython": "cp", "pypy": "pp", "ironpython": "ip", "jython": "jy", } _32_BIT_INTERPRETER = struct.calcsize("P") == 4 class Tag: """ A representation of the tag triple for a wheel. Instances are considered immutable and thus are hashable. Equality checking is also supported. """ __slots__ = ["_interpreter", "_abi", "_platform", "_hash"] def __init__(self, interpreter: str, abi: str, platform: str) -> None: self._interpreter = interpreter.lower() self._abi = abi.lower() self._platform = platform.lower() # The __hash__ of every single element in a Set[Tag] will be evaluated each time # that a set calls its `.disjoint()` method, which may be called hundreds of # times when scanning a page of links for packages with tags matching that # Set[Tag]. Pre-computing the value here produces significant speedups for # downstream consumers. self._hash = hash((self._interpreter, self._abi, self._platform)) @property def interpreter(self) -> str: return self._interpreter @property def abi(self) -> str: return self._abi @property def platform(self) -> str: return self._platform def __eq__(self, other: object) -> bool: if not isinstance(other, Tag): return NotImplemented return ( (self._hash == other._hash) # Short-circuit ASAP for perf reasons. and (self._platform == other._platform) and (self._abi == other._abi) and (self._interpreter == other._interpreter) ) def __hash__(self) -> int: return self._hash def __str__(self) -> str: return f"{self._interpreter}-{self._abi}-{self._platform}" def __repr__(self) -> str: return f"<{self} @ {id(self)}>" def parse_tag(tag: str) -> frozenset[Tag]: """ Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. Returning a set is required due to the possibility that the tag is a compressed tag set. """ tags = set() interpreters, abis, platforms = tag.split("-") for interpreter in interpreters.split("."): for abi in abis.split("."): for platform_ in platforms.split("."): tags.add(Tag(interpreter, abi, platform_)) return frozenset(tags) def _get_config_var(name: str, warn: bool = False) -> int | str | None: value: int | str | None = sysconfig.get_config_var(name) if value is None and warn: logger.debug( "Config variable '%s' is unset, Python ABI tag may be incorrect", name ) return value def _normalize_string(string: str) -> str: return string.replace(".", "_").replace("-", "_").replace(" ", "_") def _is_threaded_cpython(abis: list[str]) -> bool: """ Determine if the ABI corresponds to a threaded (`--disable-gil`) build. The threaded builds are indicated by a "t" in the abiflags. """ if len(abis) == 0: return False # expect e.g., cp313 m = re.match(r"cp\d+(.*)", abis[0]) if not m: return False abiflags = m.group(1) return "t" in abiflags def _abi3_applies(python_version: PythonVersion, threading: bool) -> bool: """ Determine if the Python version supports abi3. PEP 384 was first implemented in Python 3.2. The threaded (`--disable-gil`) builds do not support abi3. """ return len(python_version) > 1 and tuple(python_version) >= (3, 2) and not threading def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> list[str]: py_version = tuple(py_version) # To allow for version comparison. abis = [] version = _version_nodot(py_version[:2]) threading = debug = pymalloc = ucs4 = "" with_debug = _get_config_var("Py_DEBUG", warn) has_refcount = hasattr(sys, "gettotalrefcount") # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled # extension modules is the best option. # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 has_ext = "_d.pyd" in EXTENSION_SUFFIXES if with_debug or (with_debug is None and (has_refcount or has_ext)): debug = "d" if py_version >= (3, 13) and _get_config_var("Py_GIL_DISABLED", warn): threading = "t" if py_version < (3, 8): with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) if with_pymalloc or with_pymalloc is None: pymalloc = "m" if py_version < (3, 3): unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) if unicode_size == 4 or ( unicode_size is None and sys.maxunicode == 0x10FFFF ): ucs4 = "u" elif debug: # Debug builds can also load "normal" extension modules. # We can also assume no UCS-4 or pymalloc requirement. abis.append(f"cp{version}{threading}") abis.insert(0, f"cp{version}{threading}{debug}{pymalloc}{ucs4}") return abis def cpython_tags( python_version: PythonVersion | None = None, abis: Iterable[str] | None = None, platforms: Iterable[str] | None = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a CPython interpreter. The tags consist of: - cp<python_version>-<abi>-<platform> - cp<python_version>-abi3-<platform> - cp<python_version>-none-<platform> - cp<less than python_version>-abi3-<platform> # Older Python versions down to 3.2. If python_version only specifies a major version then user-provided ABIs and the 'none' ABItag will be used. If 'abi3' or 'none' are specified in 'abis' then they will be yielded at their normal position and not at the beginning. """ if not python_version: python_version = sys.version_info[:2] interpreter = f"cp{_version_nodot(python_version[:2])}" if abis is None: if len(python_version) > 1: abis = _cpython_abis(python_version, warn) else: abis = [] abis = list(abis) # 'abi3' and 'none' are explicitly handled later. for explicit_abi in ("abi3", "none"): try: abis.remove(explicit_abi) except ValueError: pass platforms = list(platforms or platform_tags()) for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) threading = _is_threaded_cpython(abis) use_abi3 = _abi3_applies(python_version, threading) if use_abi3: yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) if use_abi3: for minor_version in range(python_version[1] - 1, 1, -1): for platform_ in platforms: interpreter = "cp{version}".format( version=_version_nodot((python_version[0], minor_version)) ) yield Tag(interpreter, "abi3", platform_) def _generic_abi() -> list[str]: """ Return the ABI tag based on EXT_SUFFIX. """ # The following are examples of `EXT_SUFFIX`. # We want to keep the parts which are related to the ABI and remove the # parts which are related to the platform: # - linux: '.cpython-310-x86_64-linux-gnu.so' => cp310 # - mac: '.cpython-310-darwin.so' => cp310 # - win: '.cp310-win_amd64.pyd' => cp310 # - win: '.pyd' => cp37 (uses _cpython_abis()) # - pypy: '.pypy38-pp73-x86_64-linux-gnu.so' => pypy38_pp73 # - graalpy: '.graalpy-38-native-x86_64-darwin.dylib' # => graalpy_38_native ext_suffix = _get_config_var("EXT_SUFFIX", warn=True) if not isinstance(ext_suffix, str) or ext_suffix[0] != ".": raise SystemError("invalid sysconfig.get_config_var('EXT_SUFFIX')") parts = ext_suffix.split(".") if len(parts) < 3: # CPython3.7 and earlier uses ".pyd" on Windows. return _cpython_abis(sys.version_info[:2]) soabi = parts[1] if soabi.startswith("cpython"): # non-windows abi = "cp" + soabi.split("-")[1] elif soabi.startswith("cp"): # windows abi = soabi.split("-")[0] elif soabi.startswith("pypy"): abi = "-".join(soabi.split("-")[:2]) elif soabi.startswith("graalpy"): abi = "-".join(soabi.split("-")[:3]) elif soabi: # pyston, ironpython, others? abi = soabi else: return [] return [_normalize_string(abi)] def generic_tags( interpreter: str | None = None, abis: Iterable[str] | None = None, platforms: Iterable[str] | None = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a generic interpreter. The tags consist of: - <interpreter>-<abi>-<platform> The "none" ABI will be added if it was not explicitly provided. """ if not interpreter: interp_name = interpreter_name() interp_version = interpreter_version(warn=warn) interpreter = "".join([interp_name, interp_version]) if abis is None: abis = _generic_abi() else: abis = list(abis) platforms = list(platforms or platform_tags()) if "none" not in abis: abis.append("none") for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: """ Yields Python versions in descending order. After the latest version, the major-only version will be yielded, and then all previous versions of that major version. """ if len(py_version) > 1: yield f"py{_version_nodot(py_version[:2])}" yield f"py{py_version[0]}" if len(py_version) > 1: for minor in range(py_version[1] - 1, -1, -1): yield f"py{_version_nodot((py_version[0], minor))}" def compatible_tags( python_version: PythonVersion | None = None, interpreter: str | None = None, platforms: Iterable[str] | None = None, ) -> Iterator[Tag]: """ Yields the sequence of tags that are compatible with a specific version of Python. The tags consist of: - py*-none-<platform> - <interpreter>-none-any # ... if `interpreter` is provided. - py*-none-any """ if not python_version: python_version = sys.version_info[:2] platforms = list(platforms or platform_tags()) for version in _py_interpreter_range(python_version): for platform_ in platforms: yield Tag(version, "none", platform_) if interpreter: yield Tag(interpreter, "none", "any") for version in _py_interpreter_range(python_version): yield Tag(version, "none", "any") def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: if not is_32bit: return arch if arch.startswith("ppc"): return "ppc" return "i386" def _mac_binary_formats(version: AppleVersion, cpu_arch: str) -> list[str]: formats = [cpu_arch] if cpu_arch == "x86_64": if version < (10, 4): return [] formats.extend(["intel", "fat64", "fat32"]) elif cpu_arch == "i386": if version < (10, 4): return [] formats.extend(["intel", "fat32", "fat"]) elif cpu_arch == "ppc64": # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? if version > (10, 5) or version < (10, 4): return [] formats.append("fat64") elif cpu_arch == "ppc": if version > (10, 6): return [] formats.extend(["fat32", "fat"]) if cpu_arch in {"arm64", "x86_64"}: formats.append("universal2") if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: formats.append("universal") return formats def mac_platforms( version: AppleVersion | None = None, arch: str | None = None ) -> Iterator[str]: """ Yields the platform tags for a macOS system. The `version` parameter is a two-item tuple specifying the macOS version to generate platform tags for. The `arch` parameter is the CPU architecture to generate platform tags for. Both parameters default to the appropriate value for the current system. """ version_str, _, cpu_arch = platform.mac_ver() if version is None: version = cast("AppleVersion", tuple(map(int, version_str.split(".")[:2]))) if version == (10, 16): # When built against an older macOS SDK, Python will report macOS 10.16 # instead of the real version. version_str = subprocess.run( [ sys.executable, "-sS", "-c", "import platform; print(platform.mac_ver()[0])", ], check=True, env={"SYSTEM_VERSION_COMPAT": "0"}, stdout=subprocess.PIPE, text=True, ).stdout version = cast("AppleVersion", tuple(map(int, version_str.split(".")[:2]))) else: version = version if arch is None: arch = _mac_arch(cpu_arch) else: arch = arch if (10, 0) <= version and version < (11, 0): # Prior to Mac OS 11, each yearly release of Mac OS bumped the # "minor" version number. The major version was always 10. for minor_version in range(version[1], -1, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=10, minor=minor_version, binary_format=binary_format ) if version >= (11, 0): # Starting with Mac OS 11, each yearly release bumps the major version # number. The minor versions are now the midyear updates. for major_version in range(version[0], 10, -1): compat_version = major_version, 0 binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=major_version, minor=0, binary_format=binary_format ) if version >= (11, 0): # Mac OS 11 on x86_64 is compatible with binaries from previous releases. # Arm64 support was introduced in 11.0, so no Arm binaries from previous # releases exist. # # However, the "universal2" binary format can have a # macOS version earlier than 11.0 when the x86_64 part of the binary supports # that version of macOS. if arch == "x86_64": for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) else: for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_format = "universal2" yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) def ios_platforms( version: AppleVersion | None = None, multiarch: str | None = None ) -> Iterator[str]: """ Yields the platform tags for an iOS system. :param version: A two-item tuple specifying the iOS version to generate platform tags for. Defaults to the current iOS version. :param multiarch: The CPU architecture+ABI to generate platform tags for - (the value used by `sys.implementation._multiarch` e.g., `arm64_iphoneos` or `x84_64_iphonesimulator`). Defaults to the current multiarch value. """ if version is None: # if iOS is the current platform, ios_ver *must* be defined. However, # it won't exist for CPython versions before 3.13, which causes a mypy # error. _, release, _, _ = platform.ios_ver() # type: ignore[attr-defined] version = cast("AppleVersion", tuple(map(int, release.split(".")[:2]))) if multiarch is None: multiarch = sys.implementation._multiarch multiarch = multiarch.replace("-", "_") ios_platform_template = "ios_{major}_{minor}_{multiarch}" # Consider any iOS major.minor version from the version requested, down to # 12.0. 12.0 is the first iOS version that is known to have enough features # to support CPython. Consider every possible minor release up to X.9. There # highest the minor has ever gone is 8 (14.8 and 15.8) but having some extra # candidates that won't ever match doesn't really hurt, and it saves us from # having to keep an explicit list of known iOS versions in the code. Return # the results descending order of version number. # If the requested major version is less than 12, there won't be any matches. if version[0] < 12: return # Consider the actual X.Y version that was requested. yield ios_platform_template.format( major=version[0], minor=version[1], multiarch=multiarch ) # Consider every minor version from X.0 to the minor version prior to the # version requested by the platform. for minor in range(version[1] - 1, -1, -1): yield ios_platform_template.format( major=version[0], minor=minor, multiarch=multiarch ) for major in range(version[0] - 1, 11, -1): for minor in range(9, -1, -1): yield ios_platform_template.format( major=major, minor=minor, multiarch=multiarch ) def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: linux = _normalize_string(sysconfig.get_platform()) if not linux.startswith("linux_"): # we should never be here, just yield the sysconfig one and return yield linux return if is_32bit: if linux == "linux_x86_64": linux = "linux_i686" elif linux == "linux_aarch64": linux = "linux_armv8l" _, arch = linux.split("_", 1) archs = {"armv8l": ["armv8l", "armv7l"]}.get(arch, [arch]) yield from _manylinux.platform_tags(archs) yield from _musllinux.platform_tags(archs) for arch in archs: yield f"linux_{arch}" def _generic_platforms() -> Iterator[str]: yield _normalize_string(sysconfig.get_platform()) def platform_tags() -> Iterator[str]: """ Provides the platform tags for this installation. """ if platform.system() == "Darwin": return mac_platforms() elif platform.system() == "iOS": return ios_platforms() elif platform.system() == "Linux": return _linux_platforms() else: return _generic_platforms() def interpreter_name() -> str: """ Returns the name of the running interpreter. Some implementations have a reserved, two-letter abbreviation which will be returned when appropriate. """ name = sys.implementation.name return INTERPRETER_SHORT_NAMES.get(name) or name def interpreter_version(*, warn: bool = False) -> str: """ Returns the version of the running interpreter. """ version = _get_config_var("py_version_nodot", warn=warn) if version: version = str(version) else: version = _version_nodot(sys.version_info[:2]) return version def _version_nodot(version: PythonVersion) -> str: return "".join(map(str, version)) def sys_tags(*, warn: bool = False) -> Iterator[Tag]: """ Returns the sequence of tag triples for the running interpreter. The order of the sequence corresponds to priority order for the interpreter, from most to least important. """ interp_name = interpreter_name() if interp_name == "cp": yield from cpython_tags(warn=warn) else: yield from generic_tags() if interp_name == "pp": interp = "pp3" elif interp_name == "cp": interp = "cp" + interpreter_version(warn=warn) else: interp = None yield from compatible_tags(interpreter=interp) utils.py 0000644 00000012247 15004414131 0006255 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. from __future__ import annotations import re from typing import NewType, Tuple, Union, cast from .tags import Tag, parse_tag from .version import InvalidVersion, Version BuildTag = Union[Tuple[()], Tuple[int, str]] NormalizedName = NewType("NormalizedName", str) class InvalidName(ValueError): """ An invalid distribution name; users should refer to the packaging user guide. """ class InvalidWheelFilename(ValueError): """ An invalid wheel filename was found, users should refer to PEP 427. """ class InvalidSdistFilename(ValueError): """ An invalid sdist filename was found, users should refer to the packaging user guide. """ # Core metadata spec for `Name` _validate_regex = re.compile( r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", re.IGNORECASE ) _canonicalize_regex = re.compile(r"[-_.]+") _normalized_regex = re.compile(r"^([a-z0-9]|[a-z0-9]([a-z0-9-](?!--))*[a-z0-9])$") # PEP 427: The build number must start with a digit. _build_tag_regex = re.compile(r"(\d+)(.*)") def canonicalize_name(name: str, *, validate: bool = False) -> NormalizedName: if validate and not _validate_regex.match(name): raise InvalidName(f"name is invalid: {name!r}") # This is taken from PEP 503. value = _canonicalize_regex.sub("-", name).lower() return cast(NormalizedName, value) def is_normalized_name(name: str) -> bool: return _normalized_regex.match(name) is not None def canonicalize_version( version: Version | str, *, strip_trailing_zero: bool = True ) -> str: """ This is very similar to Version.__str__, but has one subtle difference with the way it handles the release segment. """ if isinstance(version, str): try: parsed = Version(version) except InvalidVersion: # Legacy versions cannot be normalized return version else: parsed = version parts = [] # Epoch if parsed.epoch != 0: parts.append(f"{parsed.epoch}!") # Release segment release_segment = ".".join(str(x) for x in parsed.release) if strip_trailing_zero: # NB: This strips trailing '.0's to normalize release_segment = re.sub(r"(\.0)+$", "", release_segment) parts.append(release_segment) # Pre-release if parsed.pre is not None: parts.append("".join(str(x) for x in parsed.pre)) # Post-release if parsed.post is not None: parts.append(f".post{parsed.post}") # Development release if parsed.dev is not None: parts.append(f".dev{parsed.dev}") # Local version segment if parsed.local is not None: parts.append(f"+{parsed.local}") return "".join(parts) def parse_wheel_filename( filename: str, ) -> tuple[NormalizedName, Version, BuildTag, frozenset[Tag]]: if not filename.endswith(".whl"): raise InvalidWheelFilename( f"Invalid wheel filename (extension must be '.whl'): {filename}" ) filename = filename[:-4] dashes = filename.count("-") if dashes not in (4, 5): raise InvalidWheelFilename( f"Invalid wheel filename (wrong number of parts): {filename}" ) parts = filename.split("-", dashes - 2) name_part = parts[0] # See PEP 427 for the rules on escaping the project name. if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: raise InvalidWheelFilename(f"Invalid project name: {filename}") name = canonicalize_name(name_part) try: version = Version(parts[1]) except InvalidVersion as e: raise InvalidWheelFilename( f"Invalid wheel filename (invalid version): {filename}" ) from e if dashes == 5: build_part = parts[2] build_match = _build_tag_regex.match(build_part) if build_match is None: raise InvalidWheelFilename( f"Invalid build number: {build_part} in '{filename}'" ) build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) else: build = () tags = parse_tag(parts[-1]) return (name, version, build, tags) def parse_sdist_filename(filename: str) -> tuple[NormalizedName, Version]: if filename.endswith(".tar.gz"): file_stem = filename[: -len(".tar.gz")] elif filename.endswith(".zip"): file_stem = filename[: -len(".zip")] else: raise InvalidSdistFilename( f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" f" {filename}" ) # We are requiring a PEP 440 version, which cannot contain dashes, # so we split on the last dash. name_part, sep, version_part = file_stem.rpartition("-") if not sep: raise InvalidSdistFilename(f"Invalid sdist filename: {filename}") name = canonicalize_name(name_part) try: version = Version(version_part) except InvalidVersion as e: raise InvalidSdistFilename( f"Invalid sdist filename (invalid version): {filename}" ) from e return (name, version) version.py 0000644 00000037522 15004414131 0006605 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. """ .. testsetup:: from pip._vendor.packaging.version import parse, Version """ from __future__ import annotations import itertools import re from typing import Any, Callable, NamedTuple, SupportsInt, Tuple, Union from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType __all__ = ["VERSION_PATTERN", "parse", "Version", "InvalidVersion"] LocalType = Tuple[Union[int, str], ...] CmpPrePostDevType = Union[InfinityType, NegativeInfinityType, Tuple[str, int]] CmpLocalType = Union[ NegativeInfinityType, Tuple[Union[Tuple[int, str], Tuple[NegativeInfinityType, Union[int, str]]], ...], ] CmpKey = Tuple[ int, Tuple[int, ...], CmpPrePostDevType, CmpPrePostDevType, CmpPrePostDevType, CmpLocalType, ] VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool] class _Version(NamedTuple): epoch: int release: tuple[int, ...] dev: tuple[str, int] | None pre: tuple[str, int] | None post: tuple[str, int] | None local: LocalType | None def parse(version: str) -> Version: """Parse the given version string. >>> parse('1.0.dev1') <Version('1.0.dev1')> :param version: The version string to parse. :raises InvalidVersion: When the version string is not a valid version. """ return Version(version) class InvalidVersion(ValueError): """Raised when a version string is not a valid version. >>> Version("invalid") Traceback (most recent call last): ... packaging.version.InvalidVersion: Invalid version: 'invalid' """ class _BaseVersion: _key: tuple[Any, ...] def __hash__(self) -> int: return hash(self._key) # Please keep the duplicated `isinstance` check # in the six comparisons hereunder # unless you find a way to avoid adding overhead function calls. def __lt__(self, other: _BaseVersion) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key < other._key def __le__(self, other: _BaseVersion) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key <= other._key def __eq__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key == other._key def __ge__(self, other: _BaseVersion) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key >= other._key def __gt__(self, other: _BaseVersion) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key > other._key def __ne__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key != other._key # Deliberately not anchored to the start and end of the string, to make it # easier for 3rd party code to reuse _VERSION_PATTERN = r""" v? (?: (?:(?P<epoch>[0-9]+)!)? # epoch (?P<release>[0-9]+(?:\.[0-9]+)*) # release segment (?P<pre> # pre-release [-_\.]? (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc) [-_\.]? (?P<pre_n>[0-9]+)? )? (?P<post> # post release (?:-(?P<post_n1>[0-9]+)) | (?: [-_\.]? (?P<post_l>post|rev|r) [-_\.]? (?P<post_n2>[0-9]+)? ) )? (?P<dev> # dev release [-_\.]? (?P<dev_l>dev) [-_\.]? (?P<dev_n>[0-9]+)? )? ) (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version """ VERSION_PATTERN = _VERSION_PATTERN """ A string containing the regular expression used to match a valid version. The pattern is not anchored at either end, and is intended for embedding in larger expressions (for example, matching a version number as part of a file name). The regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE`` flags set. :meta hide-value: """ class Version(_BaseVersion): """This class abstracts handling of a project's versions. A :class:`Version` instance is comparison aware and can be compared and sorted using the standard Python interfaces. >>> v1 = Version("1.0a5") >>> v2 = Version("1.0") >>> v1 <Version('1.0a5')> >>> v2 <Version('1.0')> >>> v1 < v2 True >>> v1 == v2 False >>> v1 > v2 False >>> v1 >= v2 False >>> v1 <= v2 True """ _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE) _key: CmpKey def __init__(self, version: str) -> None: """Initialize a Version object. :param version: The string representation of a version which will be parsed and normalized before use. :raises InvalidVersion: If the ``version`` does not conform to PEP 440 in any way then this exception will be raised. """ # Validate the version and parse it into pieces match = self._regex.search(version) if not match: raise InvalidVersion(f"Invalid version: '{version}'") # Store the parsed out pieces of the version self._version = _Version( epoch=int(match.group("epoch")) if match.group("epoch") else 0, release=tuple(int(i) for i in match.group("release").split(".")), pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")), post=_parse_letter_version( match.group("post_l"), match.group("post_n1") or match.group("post_n2") ), dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")), local=_parse_local_version(match.group("local")), ) # Generate a key which will be used for sorting self._key = _cmpkey( self._version.epoch, self._version.release, self._version.pre, self._version.post, self._version.dev, self._version.local, ) def __repr__(self) -> str: """A representation of the Version that shows all internal state. >>> Version('1.0.0') <Version('1.0.0')> """ return f"<Version('{self}')>" def __str__(self) -> str: """A string representation of the version that can be rounded-tripped. >>> str(Version("1.0a5")) '1.0a5' """ parts = [] # Epoch if self.epoch != 0: parts.append(f"{self.epoch}!") # Release segment parts.append(".".join(str(x) for x in self.release)) # Pre-release if self.pre is not None: parts.append("".join(str(x) for x in self.pre)) # Post-release if self.post is not None: parts.append(f".post{self.post}") # Development release if self.dev is not None: parts.append(f".dev{self.dev}") # Local version segment if self.local is not None: parts.append(f"+{self.local}") return "".join(parts) @property def epoch(self) -> int: """The epoch of the version. >>> Version("2.0.0").epoch 0 >>> Version("1!2.0.0").epoch 1 """ return self._version.epoch @property def release(self) -> tuple[int, ...]: """The components of the "release" segment of the version. >>> Version("1.2.3").release (1, 2, 3) >>> Version("2.0.0").release (2, 0, 0) >>> Version("1!2.0.0.post0").release (2, 0, 0) Includes trailing zeroes but not the epoch or any pre-release / development / post-release suffixes. """ return self._version.release @property def pre(self) -> tuple[str, int] | None: """The pre-release segment of the version. >>> print(Version("1.2.3").pre) None >>> Version("1.2.3a1").pre ('a', 1) >>> Version("1.2.3b1").pre ('b', 1) >>> Version("1.2.3rc1").pre ('rc', 1) """ return self._version.pre @property def post(self) -> int | None: """The post-release number of the version. >>> print(Version("1.2.3").post) None >>> Version("1.2.3.post1").post 1 """ return self._version.post[1] if self._version.post else None @property def dev(self) -> int | None: """The development number of the version. >>> print(Version("1.2.3").dev) None >>> Version("1.2.3.dev1").dev 1 """ return self._version.dev[1] if self._version.dev else None @property def local(self) -> str | None: """The local version segment of the version. >>> print(Version("1.2.3").local) None >>> Version("1.2.3+abc").local 'abc' """ if self._version.local: return ".".join(str(x) for x in self._version.local) else: return None @property def public(self) -> str: """The public portion of the version. >>> Version("1.2.3").public '1.2.3' >>> Version("1.2.3+abc").public '1.2.3' >>> Version("1.2.3+abc.dev1").public '1.2.3' """ return str(self).split("+", 1)[0] @property def base_version(self) -> str: """The "base version" of the version. >>> Version("1.2.3").base_version '1.2.3' >>> Version("1.2.3+abc").base_version '1.2.3' >>> Version("1!1.2.3+abc.dev1").base_version '1!1.2.3' The "base version" is the public version of the project without any pre or post release markers. """ parts = [] # Epoch if self.epoch != 0: parts.append(f"{self.epoch}!") # Release segment parts.append(".".join(str(x) for x in self.release)) return "".join(parts) @property def is_prerelease(self) -> bool: """Whether this version is a pre-release. >>> Version("1.2.3").is_prerelease False >>> Version("1.2.3a1").is_prerelease True >>> Version("1.2.3b1").is_prerelease True >>> Version("1.2.3rc1").is_prerelease True >>> Version("1.2.3dev1").is_prerelease True """ return self.dev is not None or self.pre is not None @property def is_postrelease(self) -> bool: """Whether this version is a post-release. >>> Version("1.2.3").is_postrelease False >>> Version("1.2.3.post1").is_postrelease True """ return self.post is not None @property def is_devrelease(self) -> bool: """Whether this version is a development release. >>> Version("1.2.3").is_devrelease False >>> Version("1.2.3.dev1").is_devrelease True """ return self.dev is not None @property def major(self) -> int: """The first item of :attr:`release` or ``0`` if unavailable. >>> Version("1.2.3").major 1 """ return self.release[0] if len(self.release) >= 1 else 0 @property def minor(self) -> int: """The second item of :attr:`release` or ``0`` if unavailable. >>> Version("1.2.3").minor 2 >>> Version("1").minor 0 """ return self.release[1] if len(self.release) >= 2 else 0 @property def micro(self) -> int: """The third item of :attr:`release` or ``0`` if unavailable. >>> Version("1.2.3").micro 3 >>> Version("1").micro 0 """ return self.release[2] if len(self.release) >= 3 else 0 def _parse_letter_version( letter: str | None, number: str | bytes | SupportsInt | None ) -> tuple[str, int] | None: if letter: # We consider there to be an implicit 0 in a pre-release if there is # not a numeral associated with it. if number is None: number = 0 # We normalize any letters to their lower case form letter = letter.lower() # We consider some words to be alternate spellings of other words and # in those cases we want to normalize the spellings to our preferred # spelling. if letter == "alpha": letter = "a" elif letter == "beta": letter = "b" elif letter in ["c", "pre", "preview"]: letter = "rc" elif letter in ["rev", "r"]: letter = "post" return letter, int(number) if not letter and number: # We assume if we are given a number, but we are not given a letter # then this is using the implicit post release syntax (e.g. 1.0-1) letter = "post" return letter, int(number) return None _local_version_separators = re.compile(r"[\._-]") def _parse_local_version(local: str | None) -> LocalType | None: """ Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). """ if local is not None: return tuple( part.lower() if not part.isdigit() else int(part) for part in _local_version_separators.split(local) ) return None def _cmpkey( epoch: int, release: tuple[int, ...], pre: tuple[str, int] | None, post: tuple[str, int] | None, dev: tuple[str, int] | None, local: LocalType | None, ) -> CmpKey: # When we compare a release version, we want to compare it with all of the # trailing zeros removed. So we'll use a reverse the list, drop all the now # leading zeros until we come to something non zero, then take the rest # re-reverse it back into the correct order and make it a tuple and use # that for our sorting key. _release = tuple( reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release)))) ) # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0. # We'll do this by abusing the pre segment, but we _only_ want to do this # if there is not a pre or a post segment. If we have one of those then # the normal sorting rules will handle this case correctly. if pre is None and post is None and dev is not None: _pre: CmpPrePostDevType = NegativeInfinity # Versions without a pre-release (except as noted above) should sort after # those with one. elif pre is None: _pre = Infinity else: _pre = pre # Versions without a post segment should sort before those with one. if post is None: _post: CmpPrePostDevType = NegativeInfinity else: _post = post # Versions without a development segment should sort after those with one. if dev is None: _dev: CmpPrePostDevType = Infinity else: _dev = dev if local is None: # Versions without a local segment should sort before those with one. _local: CmpLocalType = NegativeInfinity else: # Versions with a local segment need that segment parsed to implement # the sorting rules in PEP440. # - Alpha numeric segments sort before numeric segments # - Alpha numeric segments sort lexicographically # - Numeric segments sort numerically # - Shorter versions sort before longer versions when the prefixes # match exactly _local = tuple( (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local ) return epoch, _release, _pre, _post, _dev, _local py.typed 0000644 00000000000 15004414131 0006222 0 ustar 00 _elffile.py 0000644 00000006322 15004414131 0006657 0 ustar 00 """ ELF file parser. This provides a class ``ELFFile`` that parses an ELF executable in a similar interface to ``ZipFile``. Only the read interface is implemented. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html """ from __future__ import annotations import enum import os import struct from typing import IO class ELFInvalid(ValueError): pass class EIClass(enum.IntEnum): C32 = 1 C64 = 2 class EIData(enum.IntEnum): Lsb = 1 Msb = 2 class EMachine(enum.IntEnum): I386 = 3 S390 = 22 Arm = 40 X8664 = 62 AArc64 = 183 class ELFFile: """ Representation of an ELF executable. """ def __init__(self, f: IO[bytes]) -> None: self._f = f try: ident = self._read("16B") except struct.error: raise ELFInvalid("unable to parse identification") magic = bytes(ident[:4]) if magic != b"\x7fELF": raise ELFInvalid(f"invalid magic: {magic!r}") self.capacity = ident[4] # Format for program header (bitness). self.encoding = ident[5] # Data structure encoding (endianness). try: # e_fmt: Format for program header. # p_fmt: Format for section header. # p_idx: Indexes to find p_type, p_offset, and p_filesz. e_fmt, self._p_fmt, self._p_idx = { (1, 1): ("<HHIIIIIHHH", "<IIIIIIII", (0, 1, 4)), # 32-bit LSB. (1, 2): (">HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)), # 32-bit MSB. (2, 1): ("<HHIQQQIHHH", "<IIQQQQQQ", (0, 2, 5)), # 64-bit LSB. (2, 2): (">HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)), # 64-bit MSB. }[(self.capacity, self.encoding)] except KeyError: raise ELFInvalid( f"unrecognized capacity ({self.capacity}) or " f"encoding ({self.encoding})" ) try: ( _, self.machine, # Architecture type. _, _, self._e_phoff, # Offset of program header. _, self.flags, # Processor-specific flags. _, self._e_phentsize, # Size of section. self._e_phnum, # Number of sections. ) = self._read(e_fmt) except struct.error as e: raise ELFInvalid("unable to parse machine and section information") from e def _read(self, fmt: str) -> tuple[int, ...]: return struct.unpack(fmt, self._f.read(struct.calcsize(fmt))) @property def interpreter(self) -> str | None: """ The path recorded in the ``PT_INTERP`` section header. """ for index in range(self._e_phnum): self._f.seek(self._e_phoff + self._e_phentsize * index) try: data = self._read(self._p_fmt) except struct.error: continue if data[self._p_idx[0]] != 3: # Not PT_INTERP. continue self._f.seek(data[self._p_idx[1]]) return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0") return None _parser.py 0000644 00000023774 15004414131 0006557 0 ustar 00 """Handwritten parser of dependency specifiers. The docstring for each __parse_* function contains EBNF-inspired grammar representing the implementation. """ from __future__ import annotations import ast from typing import NamedTuple, Sequence, Tuple, Union from ._tokenizer import DEFAULT_RULES, Tokenizer class Node: def __init__(self, value: str) -> None: self.value = value def __str__(self) -> str: return self.value def __repr__(self) -> str: return f"<{self.__class__.__name__}('{self}')>" def serialize(self) -> str: raise NotImplementedError class Variable(Node): def serialize(self) -> str: return str(self) class Value(Node): def serialize(self) -> str: return f'"{self}"' class Op(Node): def serialize(self) -> str: return str(self) MarkerVar = Union[Variable, Value] MarkerItem = Tuple[MarkerVar, Op, MarkerVar] MarkerAtom = Union[MarkerItem, Sequence["MarkerAtom"]] MarkerList = Sequence[Union["MarkerList", MarkerAtom, str]] class ParsedRequirement(NamedTuple): name: str url: str extras: list[str] specifier: str marker: MarkerList | None # -------------------------------------------------------------------------------------- # Recursive descent parser for dependency specifier # -------------------------------------------------------------------------------------- def parse_requirement(source: str) -> ParsedRequirement: return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES)) def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement: """ requirement = WS? IDENTIFIER WS? extras WS? requirement_details """ tokenizer.consume("WS") name_token = tokenizer.expect( "IDENTIFIER", expected="package name at the start of dependency specifier" ) name = name_token.text tokenizer.consume("WS") extras = _parse_extras(tokenizer) tokenizer.consume("WS") url, specifier, marker = _parse_requirement_details(tokenizer) tokenizer.expect("END", expected="end of dependency specifier") return ParsedRequirement(name, url, extras, specifier, marker) def _parse_requirement_details( tokenizer: Tokenizer, ) -> tuple[str, str, MarkerList | None]: """ requirement_details = AT URL (WS requirement_marker?)? | specifier WS? (requirement_marker)? """ specifier = "" url = "" marker = None if tokenizer.check("AT"): tokenizer.read() tokenizer.consume("WS") url_start = tokenizer.position url = tokenizer.expect("URL", expected="URL after @").text if tokenizer.check("END", peek=True): return (url, specifier, marker) tokenizer.expect("WS", expected="whitespace after URL") # The input might end after whitespace. if tokenizer.check("END", peek=True): return (url, specifier, marker) marker = _parse_requirement_marker( tokenizer, span_start=url_start, after="URL and whitespace" ) else: specifier_start = tokenizer.position specifier = _parse_specifier(tokenizer) tokenizer.consume("WS") if tokenizer.check("END", peek=True): return (url, specifier, marker) marker = _parse_requirement_marker( tokenizer, span_start=specifier_start, after=( "version specifier" if specifier else "name and no valid version specifier" ), ) return (url, specifier, marker) def _parse_requirement_marker( tokenizer: Tokenizer, *, span_start: int, after: str ) -> MarkerList: """ requirement_marker = SEMICOLON marker WS? """ if not tokenizer.check("SEMICOLON"): tokenizer.raise_syntax_error( f"Expected end or semicolon (after {after})", span_start=span_start, ) tokenizer.read() marker = _parse_marker(tokenizer) tokenizer.consume("WS") return marker def _parse_extras(tokenizer: Tokenizer) -> list[str]: """ extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? """ if not tokenizer.check("LEFT_BRACKET", peek=True): return [] with tokenizer.enclosing_tokens( "LEFT_BRACKET", "RIGHT_BRACKET", around="extras", ): tokenizer.consume("WS") extras = _parse_extras_list(tokenizer) tokenizer.consume("WS") return extras def _parse_extras_list(tokenizer: Tokenizer) -> list[str]: """ extras_list = identifier (wsp* ',' wsp* identifier)* """ extras: list[str] = [] if not tokenizer.check("IDENTIFIER"): return extras extras.append(tokenizer.read().text) while True: tokenizer.consume("WS") if tokenizer.check("IDENTIFIER", peek=True): tokenizer.raise_syntax_error("Expected comma between extra names") elif not tokenizer.check("COMMA"): break tokenizer.read() tokenizer.consume("WS") extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma") extras.append(extra_token.text) return extras def _parse_specifier(tokenizer: Tokenizer) -> str: """ specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS | WS? version_many WS? """ with tokenizer.enclosing_tokens( "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", around="version specifier", ): tokenizer.consume("WS") parsed_specifiers = _parse_version_many(tokenizer) tokenizer.consume("WS") return parsed_specifiers def _parse_version_many(tokenizer: Tokenizer) -> str: """ version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? """ parsed_specifiers = "" while tokenizer.check("SPECIFIER"): span_start = tokenizer.position parsed_specifiers += tokenizer.read().text if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True): tokenizer.raise_syntax_error( ".* suffix can only be used with `==` or `!=` operators", span_start=span_start, span_end=tokenizer.position + 1, ) if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True): tokenizer.raise_syntax_error( "Local version label can only be used with `==` or `!=` operators", span_start=span_start, span_end=tokenizer.position, ) tokenizer.consume("WS") if not tokenizer.check("COMMA"): break parsed_specifiers += tokenizer.read().text tokenizer.consume("WS") return parsed_specifiers # -------------------------------------------------------------------------------------- # Recursive descent parser for marker expression # -------------------------------------------------------------------------------------- def parse_marker(source: str) -> MarkerList: return _parse_full_marker(Tokenizer(source, rules=DEFAULT_RULES)) def _parse_full_marker(tokenizer: Tokenizer) -> MarkerList: retval = _parse_marker(tokenizer) tokenizer.expect("END", expected="end of marker expression") return retval def _parse_marker(tokenizer: Tokenizer) -> MarkerList: """ marker = marker_atom (BOOLOP marker_atom)+ """ expression = [_parse_marker_atom(tokenizer)] while tokenizer.check("BOOLOP"): token = tokenizer.read() expr_right = _parse_marker_atom(tokenizer) expression.extend((token.text, expr_right)) return expression def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom: """ marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? | WS? marker_item WS? """ tokenizer.consume("WS") if tokenizer.check("LEFT_PARENTHESIS", peek=True): with tokenizer.enclosing_tokens( "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", around="marker expression", ): tokenizer.consume("WS") marker: MarkerAtom = _parse_marker(tokenizer) tokenizer.consume("WS") else: marker = _parse_marker_item(tokenizer) tokenizer.consume("WS") return marker def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem: """ marker_item = WS? marker_var WS? marker_op WS? marker_var WS? """ tokenizer.consume("WS") marker_var_left = _parse_marker_var(tokenizer) tokenizer.consume("WS") marker_op = _parse_marker_op(tokenizer) tokenizer.consume("WS") marker_var_right = _parse_marker_var(tokenizer) tokenizer.consume("WS") return (marker_var_left, marker_op, marker_var_right) def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar: """ marker_var = VARIABLE | QUOTED_STRING """ if tokenizer.check("VARIABLE"): return process_env_var(tokenizer.read().text.replace(".", "_")) elif tokenizer.check("QUOTED_STRING"): return process_python_str(tokenizer.read().text) else: tokenizer.raise_syntax_error( message="Expected a marker variable or quoted string" ) def process_env_var(env_var: str) -> Variable: if env_var in ("platform_python_implementation", "python_implementation"): return Variable("platform_python_implementation") else: return Variable(env_var) def process_python_str(python_str: str) -> Value: value = ast.literal_eval(python_str) return Value(str(value)) def _parse_marker_op(tokenizer: Tokenizer) -> Op: """ marker_op = IN | NOT IN | OP """ if tokenizer.check("IN"): tokenizer.read() return Op("in") elif tokenizer.check("NOT"): tokenizer.read() tokenizer.expect("WS", expected="whitespace after 'not'") tokenizer.expect("IN", expected="'in' after 'not'") return Op("not in") elif tokenizer.check("OP"): return Op(tokenizer.read().text) else: return tokenizer.raise_syntax_error( "Expected marker operator, one of " "<=, <, !=, ==, >=, >, ~=, ===, in, not in" ) _tokenizer.py 0000644 00000012231 15004414131 0007257 0 ustar 00 from __future__ import annotations import contextlib import re from dataclasses import dataclass from typing import Iterator, NoReturn from .specifiers import Specifier @dataclass class Token: name: str text: str position: int class ParserSyntaxError(Exception): """The provided source text could not be parsed correctly.""" def __init__( self, message: str, *, source: str, span: tuple[int, int], ) -> None: self.span = span self.message = message self.source = source super().__init__() def __str__(self) -> str: marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^" return "\n ".join([self.message, self.source, marker]) DEFAULT_RULES: dict[str, str | re.Pattern[str]] = { "LEFT_PARENTHESIS": r"\(", "RIGHT_PARENTHESIS": r"\)", "LEFT_BRACKET": r"\[", "RIGHT_BRACKET": r"\]", "SEMICOLON": r";", "COMMA": r",", "QUOTED_STRING": re.compile( r""" ( ('[^']*') | ("[^"]*") ) """, re.VERBOSE, ), "OP": r"(===|==|~=|!=|<=|>=|<|>)", "BOOLOP": r"\b(or|and)\b", "IN": r"\bin\b", "NOT": r"\bnot\b", "VARIABLE": re.compile( r""" \b( python_version |python_full_version |os[._]name |sys[._]platform |platform_(release|system) |platform[._](version|machine|python_implementation) |python_implementation |implementation_(name|version) |extra )\b """, re.VERBOSE, ), "SPECIFIER": re.compile( Specifier._operator_regex_str + Specifier._version_regex_str, re.VERBOSE | re.IGNORECASE, ), "AT": r"\@", "URL": r"[^ \t]+", "IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b", "VERSION_PREFIX_TRAIL": r"\.\*", "VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*", "WS": r"[ \t]+", "END": r"$", } class Tokenizer: """Context-sensitive token parsing. Provides methods to examine the input stream to check whether the next token matches. """ def __init__( self, source: str, *, rules: dict[str, str | re.Pattern[str]], ) -> None: self.source = source self.rules: dict[str, re.Pattern[str]] = { name: re.compile(pattern) for name, pattern in rules.items() } self.next_token: Token | None = None self.position = 0 def consume(self, name: str) -> None: """Move beyond provided token name, if at current position.""" if self.check(name): self.read() def check(self, name: str, *, peek: bool = False) -> bool: """Check whether the next token has the provided name. By default, if the check succeeds, the token *must* be read before another check. If `peek` is set to `True`, the token is not loaded and would need to be checked again. """ assert ( self.next_token is None ), f"Cannot check for {name!r}, already have {self.next_token!r}" assert name in self.rules, f"Unknown token name: {name!r}" expression = self.rules[name] match = expression.match(self.source, self.position) if match is None: return False if not peek: self.next_token = Token(name, match[0], self.position) return True def expect(self, name: str, *, expected: str) -> Token: """Expect a certain token name next, failing with a syntax error otherwise. The token is *not* read. """ if not self.check(name): raise self.raise_syntax_error(f"Expected {expected}") return self.read() def read(self) -> Token: """Consume the next token and return it.""" token = self.next_token assert token is not None self.position += len(token.text) self.next_token = None return token def raise_syntax_error( self, message: str, *, span_start: int | None = None, span_end: int | None = None, ) -> NoReturn: """Raise ParserSyntaxError at the given position.""" span = ( self.position if span_start is None else span_start, self.position if span_end is None else span_end, ) raise ParserSyntaxError( message, source=self.source, span=span, ) @contextlib.contextmanager def enclosing_tokens( self, open_token: str, close_token: str, *, around: str ) -> Iterator[None]: if self.check(open_token): open_position = self.position self.read() else: open_position = None yield if open_position is None: return if not self.check(close_token): self.raise_syntax_error( f"Expected matching {close_token} for {open_token}, after {around}", span_start=open_position, ) self.read() metadata.py 0000644 00000077135 15004414131 0006704 0 ustar 00 from __future__ import annotations import email.feedparser import email.header import email.message import email.parser import email.policy import typing from typing import ( Any, Callable, Generic, Literal, TypedDict, cast, ) from . import requirements, specifiers, utils from . import version as version_module T = typing.TypeVar("T") try: ExceptionGroup except NameError: # pragma: no cover class ExceptionGroup(Exception): """A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11. If :external:exc:`ExceptionGroup` is already defined by Python itself, that version is used instead. """ message: str exceptions: list[Exception] def __init__(self, message: str, exceptions: list[Exception]) -> None: self.message = message self.exceptions = exceptions def __repr__(self) -> str: return f"{self.__class__.__name__}({self.message!r}, {self.exceptions!r})" else: # pragma: no cover ExceptionGroup = ExceptionGroup class InvalidMetadata(ValueError): """A metadata field contains invalid data.""" field: str """The name of the field that contains invalid data.""" def __init__(self, field: str, message: str) -> None: self.field = field super().__init__(message) # The RawMetadata class attempts to make as few assumptions about the underlying # serialization formats as possible. The idea is that as long as a serialization # formats offer some very basic primitives in *some* way then we can support # serializing to and from that format. class RawMetadata(TypedDict, total=False): """A dictionary of raw core metadata. Each field in core metadata maps to a key of this dictionary (when data is provided). The key is lower-case and underscores are used instead of dashes compared to the equivalent core metadata field. Any core metadata field that can be specified multiple times or can hold multiple values in a single field have a key with a plural name. See :class:`Metadata` whose attributes match the keys of this dictionary. Core metadata fields that can be specified multiple times are stored as a list or dict depending on which is appropriate for the field. Any fields which hold multiple values in a single field are stored as a list. """ # Metadata 1.0 - PEP 241 metadata_version: str name: str version: str platforms: list[str] summary: str description: str keywords: list[str] home_page: str author: str author_email: str license: str # Metadata 1.1 - PEP 314 supported_platforms: list[str] download_url: str classifiers: list[str] requires: list[str] provides: list[str] obsoletes: list[str] # Metadata 1.2 - PEP 345 maintainer: str maintainer_email: str requires_dist: list[str] provides_dist: list[str] obsoletes_dist: list[str] requires_python: str requires_external: list[str] project_urls: dict[str, str] # Metadata 2.0 # PEP 426 attempted to completely revamp the metadata format # but got stuck without ever being able to build consensus on # it and ultimately ended up withdrawn. # # However, a number of tools had started emitting METADATA with # `2.0` Metadata-Version, so for historical reasons, this version # was skipped. # Metadata 2.1 - PEP 566 description_content_type: str provides_extra: list[str] # Metadata 2.2 - PEP 643 dynamic: list[str] # Metadata 2.3 - PEP 685 # No new fields were added in PEP 685, just some edge case were # tightened up to provide better interoptability. _STRING_FIELDS = { "author", "author_email", "description", "description_content_type", "download_url", "home_page", "license", "maintainer", "maintainer_email", "metadata_version", "name", "requires_python", "summary", "version", } _LIST_FIELDS = { "classifiers", "dynamic", "obsoletes", "obsoletes_dist", "platforms", "provides", "provides_dist", "provides_extra", "requires", "requires_dist", "requires_external", "supported_platforms", } _DICT_FIELDS = { "project_urls", } def _parse_keywords(data: str) -> list[str]: """Split a string of comma-separate keyboards into a list of keywords.""" return [k.strip() for k in data.split(",")] def _parse_project_urls(data: list[str]) -> dict[str, str]: """Parse a list of label/URL string pairings separated by a comma.""" urls = {} for pair in data: # Our logic is slightly tricky here as we want to try and do # *something* reasonable with malformed data. # # The main thing that we have to worry about, is data that does # not have a ',' at all to split the label from the Value. There # isn't a singular right answer here, and we will fail validation # later on (if the caller is validating) so it doesn't *really* # matter, but since the missing value has to be an empty str # and our return value is dict[str, str], if we let the key # be the missing value, then they'd have multiple '' values that # overwrite each other in a accumulating dict. # # The other potentional issue is that it's possible to have the # same label multiple times in the metadata, with no solid "right" # answer with what to do in that case. As such, we'll do the only # thing we can, which is treat the field as unparseable and add it # to our list of unparsed fields. parts = [p.strip() for p in pair.split(",", 1)] parts.extend([""] * (max(0, 2 - len(parts)))) # Ensure 2 items # TODO: The spec doesn't say anything about if the keys should be # considered case sensitive or not... logically they should # be case-preserving and case-insensitive, but doing that # would open up more cases where we might have duplicate # entries. label, url = parts if label in urls: # The label already exists in our set of urls, so this field # is unparseable, and we can just add the whole thing to our # unparseable data and stop processing it. raise KeyError("duplicate labels in project urls") urls[label] = url return urls def _get_payload(msg: email.message.Message, source: bytes | str) -> str: """Get the body of the message.""" # If our source is a str, then our caller has managed encodings for us, # and we don't need to deal with it. if isinstance(source, str): payload: str = msg.get_payload() return payload # If our source is a bytes, then we're managing the encoding and we need # to deal with it. else: bpayload: bytes = msg.get_payload(decode=True) try: return bpayload.decode("utf8", "strict") except UnicodeDecodeError: raise ValueError("payload in an invalid encoding") # The various parse_FORMAT functions here are intended to be as lenient as # possible in their parsing, while still returning a correctly typed # RawMetadata. # # To aid in this, we also generally want to do as little touching of the # data as possible, except where there are possibly some historic holdovers # that make valid data awkward to work with. # # While this is a lower level, intermediate format than our ``Metadata`` # class, some light touch ups can make a massive difference in usability. # Map METADATA fields to RawMetadata. _EMAIL_TO_RAW_MAPPING = { "author": "author", "author-email": "author_email", "classifier": "classifiers", "description": "description", "description-content-type": "description_content_type", "download-url": "download_url", "dynamic": "dynamic", "home-page": "home_page", "keywords": "keywords", "license": "license", "maintainer": "maintainer", "maintainer-email": "maintainer_email", "metadata-version": "metadata_version", "name": "name", "obsoletes": "obsoletes", "obsoletes-dist": "obsoletes_dist", "platform": "platforms", "project-url": "project_urls", "provides": "provides", "provides-dist": "provides_dist", "provides-extra": "provides_extra", "requires": "requires", "requires-dist": "requires_dist", "requires-external": "requires_external", "requires-python": "requires_python", "summary": "summary", "supported-platform": "supported_platforms", "version": "version", } _RAW_TO_EMAIL_MAPPING = {raw: email for email, raw in _EMAIL_TO_RAW_MAPPING.items()} def parse_email(data: bytes | str) -> tuple[RawMetadata, dict[str, list[str]]]: """Parse a distribution's metadata stored as email headers (e.g. from ``METADATA``). This function returns a two-item tuple of dicts. The first dict is of recognized fields from the core metadata specification. Fields that can be parsed and translated into Python's built-in types are converted appropriately. All other fields are left as-is. Fields that are allowed to appear multiple times are stored as lists. The second dict contains all other fields from the metadata. This includes any unrecognized fields. It also includes any fields which are expected to be parsed into a built-in type but were not formatted appropriately. Finally, any fields that are expected to appear only once but are repeated are included in this dict. """ raw: dict[str, str | list[str] | dict[str, str]] = {} unparsed: dict[str, list[str]] = {} if isinstance(data, str): parsed = email.parser.Parser(policy=email.policy.compat32).parsestr(data) else: parsed = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(data) # We have to wrap parsed.keys() in a set, because in the case of multiple # values for a key (a list), the key will appear multiple times in the # list of keys, but we're avoiding that by using get_all(). for name in frozenset(parsed.keys()): # Header names in RFC are case insensitive, so we'll normalize to all # lower case to make comparisons easier. name = name.lower() # We use get_all() here, even for fields that aren't multiple use, # because otherwise someone could have e.g. two Name fields, and we # would just silently ignore it rather than doing something about it. headers = parsed.get_all(name) or [] # The way the email module works when parsing bytes is that it # unconditionally decodes the bytes as ascii using the surrogateescape # handler. When you pull that data back out (such as with get_all() ), # it looks to see if the str has any surrogate escapes, and if it does # it wraps it in a Header object instead of returning the string. # # As such, we'll look for those Header objects, and fix up the encoding. value = [] # Flag if we have run into any issues processing the headers, thus # signalling that the data belongs in 'unparsed'. valid_encoding = True for h in headers: # It's unclear if this can return more types than just a Header or # a str, so we'll just assert here to make sure. assert isinstance(h, (email.header.Header, str)) # If it's a header object, we need to do our little dance to get # the real data out of it. In cases where there is invalid data # we're going to end up with mojibake, but there's no obvious, good # way around that without reimplementing parts of the Header object # ourselves. # # That should be fine since, if mojibacked happens, this key is # going into the unparsed dict anyways. if isinstance(h, email.header.Header): # The Header object stores it's data as chunks, and each chunk # can be independently encoded, so we'll need to check each # of them. chunks: list[tuple[bytes, str | None]] = [] for bin, encoding in email.header.decode_header(h): try: bin.decode("utf8", "strict") except UnicodeDecodeError: # Enable mojibake. encoding = "latin1" valid_encoding = False else: encoding = "utf8" chunks.append((bin, encoding)) # Turn our chunks back into a Header object, then let that # Header object do the right thing to turn them into a # string for us. value.append(str(email.header.make_header(chunks))) # This is already a string, so just add it. else: value.append(h) # We've processed all of our values to get them into a list of str, # but we may have mojibake data, in which case this is an unparsed # field. if not valid_encoding: unparsed[name] = value continue raw_name = _EMAIL_TO_RAW_MAPPING.get(name) if raw_name is None: # This is a bit of a weird situation, we've encountered a key that # we don't know what it means, so we don't know whether it's meant # to be a list or not. # # Since we can't really tell one way or another, we'll just leave it # as a list, even though it may be a single item list, because that's # what makes the most sense for email headers. unparsed[name] = value continue # If this is one of our string fields, then we'll check to see if our # value is a list of a single item. If it is then we'll assume that # it was emitted as a single string, and unwrap the str from inside # the list. # # If it's any other kind of data, then we haven't the faintest clue # what we should parse it as, and we have to just add it to our list # of unparsed stuff. if raw_name in _STRING_FIELDS and len(value) == 1: raw[raw_name] = value[0] # If this is one of our list of string fields, then we can just assign # the value, since email *only* has strings, and our get_all() call # above ensures that this is a list. elif raw_name in _LIST_FIELDS: raw[raw_name] = value # Special Case: Keywords # The keywords field is implemented in the metadata spec as a str, # but it conceptually is a list of strings, and is serialized using # ", ".join(keywords), so we'll do some light data massaging to turn # this into what it logically is. elif raw_name == "keywords" and len(value) == 1: raw[raw_name] = _parse_keywords(value[0]) # Special Case: Project-URL # The project urls is implemented in the metadata spec as a list of # specially-formatted strings that represent a key and a value, which # is fundamentally a mapping, however the email format doesn't support # mappings in a sane way, so it was crammed into a list of strings # instead. # # We will do a little light data massaging to turn this into a map as # it logically should be. elif raw_name == "project_urls": try: raw[raw_name] = _parse_project_urls(value) except KeyError: unparsed[name] = value # Nothing that we've done has managed to parse this, so it'll just # throw it in our unparseable data and move on. else: unparsed[name] = value # We need to support getting the Description from the message payload in # addition to getting it from the the headers. This does mean, though, there # is the possibility of it being set both ways, in which case we put both # in 'unparsed' since we don't know which is right. try: payload = _get_payload(parsed, data) except ValueError: unparsed.setdefault("description", []).append( parsed.get_payload(decode=isinstance(data, bytes)) ) else: if payload: # Check to see if we've already got a description, if so then both # it, and this body move to unparseable. if "description" in raw: description_header = cast(str, raw.pop("description")) unparsed.setdefault("description", []).extend( [description_header, payload] ) elif "description" in unparsed: unparsed["description"].append(payload) else: raw["description"] = payload # We need to cast our `raw` to a metadata, because a TypedDict only support # literal key names, but we're computing our key names on purpose, but the # way this function is implemented, our `TypedDict` can only have valid key # names. return cast(RawMetadata, raw), unparsed _NOT_FOUND = object() # Keep the two values in sync. _VALID_METADATA_VERSIONS = ["1.0", "1.1", "1.2", "2.1", "2.2", "2.3"] _MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3"] _REQUIRED_ATTRS = frozenset(["metadata_version", "name", "version"]) class _Validator(Generic[T]): """Validate a metadata field. All _process_*() methods correspond to a core metadata field. The method is called with the field's raw value. If the raw value is valid it is returned in its "enriched" form (e.g. ``version.Version`` for the ``Version`` field). If the raw value is invalid, :exc:`InvalidMetadata` is raised (with a cause as appropriate). """ name: str raw_name: str added: _MetadataVersion def __init__( self, *, added: _MetadataVersion = "1.0", ) -> None: self.added = added def __set_name__(self, _owner: Metadata, name: str) -> None: self.name = name self.raw_name = _RAW_TO_EMAIL_MAPPING[name] def __get__(self, instance: Metadata, _owner: type[Metadata]) -> T: # With Python 3.8, the caching can be replaced with functools.cached_property(). # No need to check the cache as attribute lookup will resolve into the # instance's __dict__ before __get__ is called. cache = instance.__dict__ value = instance._raw.get(self.name) # To make the _process_* methods easier, we'll check if the value is None # and if this field is NOT a required attribute, and if both of those # things are true, we'll skip the the converter. This will mean that the # converters never have to deal with the None union. if self.name in _REQUIRED_ATTRS or value is not None: try: converter: Callable[[Any], T] = getattr(self, f"_process_{self.name}") except AttributeError: pass else: value = converter(value) cache[self.name] = value try: del instance._raw[self.name] # type: ignore[misc] except KeyError: pass return cast(T, value) def _invalid_metadata( self, msg: str, cause: Exception | None = None ) -> InvalidMetadata: exc = InvalidMetadata( self.raw_name, msg.format_map({"field": repr(self.raw_name)}) ) exc.__cause__ = cause return exc def _process_metadata_version(self, value: str) -> _MetadataVersion: # Implicitly makes Metadata-Version required. if value not in _VALID_METADATA_VERSIONS: raise self._invalid_metadata(f"{value!r} is not a valid metadata version") return cast(_MetadataVersion, value) def _process_name(self, value: str) -> str: if not value: raise self._invalid_metadata("{field} is a required field") # Validate the name as a side-effect. try: utils.canonicalize_name(value, validate=True) except utils.InvalidName as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) else: return value def _process_version(self, value: str) -> version_module.Version: if not value: raise self._invalid_metadata("{field} is a required field") try: return version_module.parse(value) except version_module.InvalidVersion as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) def _process_summary(self, value: str) -> str: """Check the field contains no newlines.""" if "\n" in value: raise self._invalid_metadata("{field} must be a single line") return value def _process_description_content_type(self, value: str) -> str: content_types = {"text/plain", "text/x-rst", "text/markdown"} message = email.message.EmailMessage() message["content-type"] = value content_type, parameters = ( # Defaults to `text/plain` if parsing failed. message.get_content_type().lower(), message["content-type"].params, ) # Check if content-type is valid or defaulted to `text/plain` and thus was # not parseable. if content_type not in content_types or content_type not in value.lower(): raise self._invalid_metadata( f"{{field}} must be one of {list(content_types)}, not {value!r}" ) charset = parameters.get("charset", "UTF-8") if charset != "UTF-8": raise self._invalid_metadata( f"{{field}} can only specify the UTF-8 charset, not {list(charset)}" ) markdown_variants = {"GFM", "CommonMark"} variant = parameters.get("variant", "GFM") # Use an acceptable default. if content_type == "text/markdown" and variant not in markdown_variants: raise self._invalid_metadata( f"valid Markdown variants for {{field}} are {list(markdown_variants)}, " f"not {variant!r}", ) return value def _process_dynamic(self, value: list[str]) -> list[str]: for dynamic_field in map(str.lower, value): if dynamic_field in {"name", "version", "metadata-version"}: raise self._invalid_metadata( f"{value!r} is not allowed as a dynamic field" ) elif dynamic_field not in _EMAIL_TO_RAW_MAPPING: raise self._invalid_metadata(f"{value!r} is not a valid dynamic field") return list(map(str.lower, value)) def _process_provides_extra( self, value: list[str], ) -> list[utils.NormalizedName]: normalized_names = [] try: for name in value: normalized_names.append(utils.canonicalize_name(name, validate=True)) except utils.InvalidName as exc: raise self._invalid_metadata( f"{name!r} is invalid for {{field}}", cause=exc ) else: return normalized_names def _process_requires_python(self, value: str) -> specifiers.SpecifierSet: try: return specifiers.SpecifierSet(value) except specifiers.InvalidSpecifier as exc: raise self._invalid_metadata( f"{value!r} is invalid for {{field}}", cause=exc ) def _process_requires_dist( self, value: list[str], ) -> list[requirements.Requirement]: reqs = [] try: for req in value: reqs.append(requirements.Requirement(req)) except requirements.InvalidRequirement as exc: raise self._invalid_metadata(f"{req!r} is invalid for {{field}}", cause=exc) else: return reqs class Metadata: """Representation of distribution metadata. Compared to :class:`RawMetadata`, this class provides objects representing metadata fields instead of only using built-in types. Any invalid metadata will cause :exc:`InvalidMetadata` to be raised (with a :py:attr:`~BaseException.__cause__` attribute as appropriate). """ _raw: RawMetadata @classmethod def from_raw(cls, data: RawMetadata, *, validate: bool = True) -> Metadata: """Create an instance from :class:`RawMetadata`. If *validate* is true, all metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. """ ins = cls() ins._raw = data.copy() # Mutations occur due to caching enriched values. if validate: exceptions: list[Exception] = [] try: metadata_version = ins.metadata_version metadata_age = _VALID_METADATA_VERSIONS.index(metadata_version) except InvalidMetadata as metadata_version_exc: exceptions.append(metadata_version_exc) metadata_version = None # Make sure to check for the fields that are present, the required # fields (so their absence can be reported). fields_to_check = frozenset(ins._raw) | _REQUIRED_ATTRS # Remove fields that have already been checked. fields_to_check -= {"metadata_version"} for key in fields_to_check: try: if metadata_version: # Can't use getattr() as that triggers descriptor protocol which # will fail due to no value for the instance argument. try: field_metadata_version = cls.__dict__[key].added except KeyError: exc = InvalidMetadata(key, f"unrecognized field: {key!r}") exceptions.append(exc) continue field_age = _VALID_METADATA_VERSIONS.index( field_metadata_version ) if field_age > metadata_age: field = _RAW_TO_EMAIL_MAPPING[key] exc = InvalidMetadata( field, "{field} introduced in metadata version " "{field_metadata_version}, not {metadata_version}", ) exceptions.append(exc) continue getattr(ins, key) except InvalidMetadata as exc: exceptions.append(exc) if exceptions: raise ExceptionGroup("invalid metadata", exceptions) return ins @classmethod def from_email(cls, data: bytes | str, *, validate: bool = True) -> Metadata: """Parse metadata from email headers. If *validate* is true, the metadata will be validated. All exceptions related to validation will be gathered and raised as an :class:`ExceptionGroup`. """ raw, unparsed = parse_email(data) if validate: exceptions: list[Exception] = [] for unparsed_key in unparsed: if unparsed_key in _EMAIL_TO_RAW_MAPPING: message = f"{unparsed_key!r} has invalid data" else: message = f"unrecognized field: {unparsed_key!r}" exceptions.append(InvalidMetadata(unparsed_key, message)) if exceptions: raise ExceptionGroup("unparsed", exceptions) try: return cls.from_raw(raw, validate=validate) except ExceptionGroup as exc_group: raise ExceptionGroup( "invalid or unparsed metadata", exc_group.exceptions ) from None metadata_version: _Validator[_MetadataVersion] = _Validator() """:external:ref:`core-metadata-metadata-version` (required; validated to be a valid metadata version)""" name: _Validator[str] = _Validator() """:external:ref:`core-metadata-name` (required; validated using :func:`~packaging.utils.canonicalize_name` and its *validate* parameter)""" version: _Validator[version_module.Version] = _Validator() """:external:ref:`core-metadata-version` (required)""" dynamic: _Validator[list[str] | None] = _Validator( added="2.2", ) """:external:ref:`core-metadata-dynamic` (validated against core metadata field names and lowercased)""" platforms: _Validator[list[str] | None] = _Validator() """:external:ref:`core-metadata-platform`""" supported_platforms: _Validator[list[str] | None] = _Validator(added="1.1") """:external:ref:`core-metadata-supported-platform`""" summary: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-summary` (validated to contain no newlines)""" description: _Validator[str | None] = _Validator() # TODO 2.1: can be in body """:external:ref:`core-metadata-description`""" description_content_type: _Validator[str | None] = _Validator(added="2.1") """:external:ref:`core-metadata-description-content-type` (validated)""" keywords: _Validator[list[str] | None] = _Validator() """:external:ref:`core-metadata-keywords`""" home_page: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-home-page`""" download_url: _Validator[str | None] = _Validator(added="1.1") """:external:ref:`core-metadata-download-url`""" author: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-author`""" author_email: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-author-email`""" maintainer: _Validator[str | None] = _Validator(added="1.2") """:external:ref:`core-metadata-maintainer`""" maintainer_email: _Validator[str | None] = _Validator(added="1.2") """:external:ref:`core-metadata-maintainer-email`""" license: _Validator[str | None] = _Validator() """:external:ref:`core-metadata-license`""" classifiers: _Validator[list[str] | None] = _Validator(added="1.1") """:external:ref:`core-metadata-classifier`""" requires_dist: _Validator[list[requirements.Requirement] | None] = _Validator( added="1.2" ) """:external:ref:`core-metadata-requires-dist`""" requires_python: _Validator[specifiers.SpecifierSet | None] = _Validator( added="1.2" ) """:external:ref:`core-metadata-requires-python`""" # Because `Requires-External` allows for non-PEP 440 version specifiers, we # don't do any processing on the values. requires_external: _Validator[list[str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-requires-external`""" project_urls: _Validator[dict[str, str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-project-url`""" # PEP 685 lets us raise an error if an extra doesn't pass `Name` validation # regardless of metadata version. provides_extra: _Validator[list[utils.NormalizedName] | None] = _Validator( added="2.1", ) """:external:ref:`core-metadata-provides-extra`""" provides_dist: _Validator[list[str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-provides-dist`""" obsoletes_dist: _Validator[list[str] | None] = _Validator(added="1.2") """:external:ref:`core-metadata-obsoletes-dist`""" requires: _Validator[list[str] | None] = _Validator(added="1.1") """``Requires`` (deprecated)""" provides: _Validator[list[str] | None] = _Validator(added="1.1") """``Provides`` (deprecated)""" obsoletes: _Validator[list[str] | None] = _Validator(added="1.1") """``Obsoletes`` (deprecated)"""
| ver. 1.4 |
Github
|
.
| PHP 8.1.31 | Генерация страницы: 0.01 |
proxy
|
phpinfo
|
Настройка