o
    cu                  	   @   s  d dl Z d dlZd dlZd dlZd dlZd dlmZmZmZm	Z	m
Z
mZmZmZmZmZmZ ddlmZ ddlmZmZmZ eeef Zeeeef ZededZeeegef ZG dd	 d	eZG d
d de jdZ G dd de Z!G dd de!Z"dedeegef dedeegef fddZ#G dd de!Z$e%dZ&dede
e fddZ'dedefddZ(de
e de
e dee
e e
e f fd d!Z)G d"d# d#e Z*dS )$    N)CallableDictIterableIteratorListOptionalPatternSetTupleTypeVarUnion   )canonicalize_version)LegacyVersionVersionparseVersionTypeVar)boundc                   @   s   e Zd ZdZdS )InvalidSpecifierzH
    An invalid specifier was found, users should refer to PEP 440.
    N)__name__
__module____qualname____doc__ r   r   M/opt/certbot/lib/python3.10/site-packages/pip/_vendor/packaging/specifiers.pyr   !   s    r   c                	   @   s   e Zd ZejdefddZejdefddZejde	de
fddZejdee
 fd	d
Zejde
ddfdd
Zejddedee
 de
fddZej	ddee dee
 dee fddZdS )BaseSpecifierreturnc                 C      dS )z
        Returns the str representation of this Specifier like object. This
        should be representative of the Specifier itself.
        Nr   selfr   r   r   __str__(       zBaseSpecifier.__str__c                 C   r   )zF
        Returns a hash value for this Specifier like object.
        Nr   r   r   r   r   __hash__/   r!   zBaseSpecifier.__hash__otherc                 C   r   )zq
        Returns a boolean representing whether or not the two Specifier like
        objects are equal.
        Nr   r   r#   r   r   r   __eq__5   r!   zBaseSpecifier.__eq__c                 C   r   )zg
        Returns whether or not pre-releases as a whole are allowed by this
        specifier.
        Nr   r   r   r   r   prereleases<   r!   zBaseSpecifier.prereleasesvalueNc                 C   r   )zd
        Sets whether or not pre-releases as a whole are allowed by this
        specifier.
        Nr   r   r'   r   r   r   r&   C   r!   itemr&   c                 C   r   )zR
        Determines if the given item is contained within this specifier.
        Nr   r   r)   r&   r   r   r   containsJ   r!   zBaseSpecifier.containsiterablec                 C   r   )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   r,   r&   r   r   r   filterP   r!   zBaseSpecifier.filterN)r   r   r   abcabstractmethodstrr    intr"   objectboolr%   abstractpropertyr   r&   setterr+   r   r   r-   r   r   r   r   r   '   s,    r   )	metaclassc                   @   sl  e Zd ZU i Zeeef ed< ee ed< d+dedee	 ddfdd	Z
defd
dZdefddZedeeef fddZdefddZdede	fddZdedefddZdedefddZedefddZedefddZedee	 fdd Zejd!e	ddfd"d Zd#ede	fd$d%Z	d,d#edee	 de	fd&d'Z	d,d(ee  dee	 dee  fd)d*Z!dS )-_IndividualSpecifier
_operators_regex Nspecr&   r   c                 C   sH   | j |}|std| d|d |d f| _|| _d S )NzInvalid specifier: ''operatorversion)r:   searchr   groupstrip_spec_prereleases)r   r<   r&   matchr   r   r   __init___   s   
z_IndividualSpecifier.__init__c                 C   s8   | j d urd| jnd}d| jj dt| | dS )N, prereleases=r;   <()>)rD   r&   	__class__r   r1   r   prer   r   r   __repr__l   s
   z_IndividualSpecifier.__repr__c                 C   s   dj | j S )Nz{}{})formatrC   r   r   r   r   r    u   s   z_IndividualSpecifier.__str__c                 C   s   | j d t| j d fS )Nr   r   )rC   r   r   r   r   r   _canonical_specx   s   z$_IndividualSpecifier._canonical_specc                 C   
   t | jS r.   )hashrP   r   r   r   r   r"   |      
z_IndividualSpecifier.__hash__r#   c                 C   sP   t |trz	| t|}W n ty   t Y S w t || js"tS | j|jkS r.   )
isinstancer1   rK   r   NotImplementedrP   r$   r   r   r   r%      s   
z_IndividualSpecifier.__eq__opc                 C   s   t | d| j|  }|S )N	_compare_)getattrr9   )r   rV   operator_callabler   r   r   _get_operator   s   z"_IndividualSpecifier._get_operatorr?   c                 C   s   t |ttfst|}|S r.   )rT   r   r   r   r   r?   r   r   r   _coerce_version   s   z$_IndividualSpecifier._coerce_versionc                 C   
   | j d S )Nr   rC   r   r   r   r   r>         
z_IndividualSpecifier.operatorc                 C   r]   )Nr   r^   r   r   r   r   r?      r_   z_IndividualSpecifier.versionc                 C   s   | j S r.   rD   r   r   r   r   r&      s   z _IndividualSpecifier.prereleasesr'   c                 C   
   || _ d S r.   r`   r(   r   r   r   r&      r_   r)   c                 C   
   |  |S r.   r+   r   r)   r   r   r   __contains__   rS   z!_IndividualSpecifier.__contains__c                 C   s>   |d u r| j }| |}|jr|sdS | | j}||| jS NF)r&   r\   is_prereleaserZ   r>   r?   )r   r)   r&   normalized_itemrY   r   r   r   r+      s   

z_IndividualSpecifier.containsr,   c                 c   s    d}g }d|d ur|ndi}|D ]#}|  |}| j|fi |r4|jr/|s/| js/|| qd}|V  q|sA|rC|D ]	}|V  q;d S d S d S )NFr&   T)r\   r+   rg   r&   append)r   r,   r&   yieldedfound_prereleaseskwr?   parsed_versionr   r   r   r-      s*   
z_IndividualSpecifier.filterr;   Nr.   )"r   r   r   r9   r   r1   __annotations__r   r   r4   rF   rN   r    propertyr
   rP   r2   r"   r3   r%   CallableOperatorrZ   UnparsedVersionParsedVersionr\   r>   r?   r&   r6   re   r+   r   r   r-   r   r   r   r   r8   Z   sJ   
 	
r8   c                       s   e Zd ZdZede d ejejB Zdddddd	d
Z	d"de
dee ddf fddZdedefddZdede
defddZdede
defddZdede
defddZdede
defddZdede
defddZdede
defd d!Z  ZS )#LegacySpecifiera  
        (?P<operator>(==|!=|<=|>=|<|>))
        \s*
        (?P<version>
            [^,;\s)]* # Since this is a "legacy" specifier, and the version
                      # string can be just about anything, we match everything
                      # except for whitespace, a semi-colon for marker support,
                      # a closing paren since versions can be enclosed in
                      # them, and a comma since it's a version separator.
        )
        ^\s*\s*$equal	not_equalless_than_equalgreater_than_equal	less_thangreater_than)==!=<=>=rH   >r;   Nr<   r&   r   c                    s   t  || tdt d S )NzZCreating a LegacyVersion has been deprecated and will be removed in the next major release)superrF   warningswarnDeprecationWarning)r   r<   r&   rK   r   r   rF      s
   zLegacySpecifier.__init__r?   c                 C   s   t |tstt|}|S r.   )rT   r   r1   r[   r   r   r   r\     s   
zLegacySpecifier._coerce_versionprospectivec                 C   s   ||  |kS r.   r\   r   r   r<   r   r   r   _compare_equal
     zLegacySpecifier._compare_equalc                 C   s   ||  |kS r.   r   r   r   r   r   _compare_not_equal  r   z"LegacySpecifier._compare_not_equalc                 C   s   ||  |kS r.   r   r   r   r   r   _compare_less_than_equal  r   z(LegacySpecifier._compare_less_than_equalc                 C   s   ||  |kS r.   r   r   r   r   r   _compare_greater_than_equal  s   z+LegacySpecifier._compare_greater_than_equalc                 C   s   ||  |k S r.   r   r   r   r   r   _compare_less_than  r   z"LegacySpecifier._compare_less_thanc                 C   s   ||  |kS r.   r   r   r   r   r   _compare_greater_than  r   z%LegacySpecifier._compare_greater_thanrn   )r   r   r   
_regex_strrecompileVERBOSE
IGNORECASEr:   r9   r1   r   r4   rF   rr   r   r\   r   r   r   r   r   r   __classcell__r   r   r   r   rt      s0     		
rt   fn	Specifierr   c              	      s,   t  dddtdtdtf fdd}|S )Nr   r   r   r<   r   c                    s   t |tsdS  | ||S rf   )rT   r   r   r   r   r   wrapped"  s   
z)_require_version_compare.<locals>.wrapped)	functoolswrapsrs   r1   r4   )r   r   r   r   r   _require_version_compare  s    r   c                	   @   s8  e Zd ZdZede d ejejB Zdddddd	d
ddZ	e
dededefddZe
dededefddZe
dededefddZe
dededefddZe
dededefddZe
dededefddZe
dededefddZdededefdd Zedefd!d"Zejd#edd$fd%d"Zd$S )&r   a  
        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
        (?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]*    # We just match everything, except for whitespace
                          # since we are only testing for strict identity.
            )
            |
            (?:
                # 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
                (?:                   # pre release
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?

                # You cannot use a wild card and a dev or local version
                # together so group them with a | and make them optional.
                (?:
                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
                    |
                    \.\*  # Wild card syntax of .*
                )?
            )
            |
            (?:
                # 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
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [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
                    [-_\.]?
                    (a|b|c|rc|alpha|beta|pre|preview)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
        )
        ru   rv   
compatiblerw   rx   ry   rz   r{   r|   	arbitrary)~=r}   r~   r   r   rH   r   ===r   r<   r   c                 C   sJ   d tttt|d d }|d7 }| d||o$| d||S )N..*r   r}   )joinlist	itertools	takewhile_is_not_suffix_version_splitrZ   )r   r   r<   prefixr   r   r   _compare_compatible  s   zSpecifier._compare_compatiblec           	      C   sv   | dr+t|j}t|d d }tt|}|d t| }t||\}}||kS t|}|js7t|j}||kS )Nr   )endswithr   publicr   r1   len_pad_versionlocal)	r   r   r<   
split_specsplit_prospectiveshortened_prospectivepadded_specpadded_prospectivespec_versionr   r   r   r     s   


zSpecifier._compare_equalc                 C   s   |  || S r.   )r   r   r   r   r   r     s   zSpecifier._compare_not_equalc                 C   s   t |jt |kS r.   r   r   r   r   r   r   r     s   z"Specifier._compare_less_than_equalc                 C   s   t |jt |kS r.   r   r   r   r   r   r     s   z%Specifier._compare_greater_than_equalspec_strc                 C   s<   t |}||k s
dS |js|jrt |jt |jkrdS dS NFT)r   rg   base_versionr   r   r   r<   r   r   r   r     s   zSpecifier._compare_less_thanc                 C   s^   t |}||ks
dS |js|jrt |jt |jkrdS |jd ur-t |jt |jkr-dS dS r   )r   is_postreleaser   r   r   r   r   r   r     s   
zSpecifier._compare_greater_thanc                 C   s   t | t | kS r.   )r1   lowerr   r   r   r   _compare_arbitrary%  s   zSpecifier._compare_arbitraryc                 C   sR   | j d ur| j S | j\}}|dv r'|dkr |dr |d d }t|jr'dS dS )N)r}   r   r   r   r   r}   r   r   TF)rD   rC   r   r   rg   )r   r>   r?   r   r   r   r&   (  s   


zSpecifier.prereleasesr'   Nc                 C   ra   r.   r`   r(   r   r   r   r&   A  r_   )r   r   r   r   r   r   r   r   r:   r9   r   rs   r1   r4   r   r   r   r   r   r   r   r   r   rp   r&   r6   r   r   r   r   r   +  sJ    ]'	z^([0-9]+)((?:a|b|c|rc)[0-9]+)$r?   c                 C   s@   g }|  dD ]}t|}|r||  q|| q|S )Nr   )split_prefix_regexr@   extendgroupsri   )r?   resultr)   rE   r   r   r   r   I  s   
r   segmentc                    s   t  fdddD  S )Nc                 3   s    | ]}  |V  qd S r.   )
startswith).0r   r   r   r   	<genexpr>U  s    

z!_is_not_suffix.<locals>.<genexpr>)devabrcpost)anyr   r   r   r   r   T  s   
r   leftrightc              
   C   s   g g }}| ttdd |  | ttdd | | | t|d d   | |t|d d   |ddgtdt|d t|d    |ddgtdt|d t|d    ttj| ttj| fS )Nc                 S      |   S r.   isdigitxr   r   r   <lambda>^      z_pad_version.<locals>.<lambda>c                 S   r   r.   r   r   r   r   r   r   _  r   r   r   0)ri   r   r   r   r   insertmaxchain)r   r   
left_splitright_splitr   r   r   r   Z  s   
,,r   c                   @   s$  e Zd Z	d#dedee ddfddZdefdd	Zdefd
dZde	fddZ
ded ef dd fddZdedefddZde	fddZdee fddZedee fddZejdeddfddZdedefddZ	d$dedee defddZ	d$d ee dee dee fd!d"ZdS )%SpecifierSetr;   N
specifiersr&   r   c              	   C   sj   dd | dD }t }|D ]}z	|t| W q ty*   |t| Y qw t|| _|| _d S )Nc                 S   s   g | ]
}|  r|  qS r   )rB   r   sr   r   r   
<listcomp>s  s    z)SpecifierSet.__init__.<locals>.<listcomp>,)	r   setaddr   r   rt   	frozenset_specsrD   )r   r   r&   split_specifiersparsed	specifierr   r   r   rF   m  s   

zSpecifierSet.__init__c                 C   s.   | j d urd| jnd}dt| | dS )NrG   r;   z<SpecifierSet(rJ   )rD   r&   r1   rL   r   r   r   rN     s
   zSpecifierSet.__repr__c                 C   s   d tdd | jD S )Nr   c                 s   s    | ]}t |V  qd S r.   )r1   r   r   r   r   r     s    z'SpecifierSet.__str__.<locals>.<genexpr>)r   sortedr   r   r   r   r   r      s   zSpecifierSet.__str__c                 C   rQ   r.   )rR   r   r   r   r   r   r"     rS   zSpecifierSet.__hash__r#   c                 C   s   t |tr
t|}nt |tstS t }t| j|jB |_| jd u r-|jd ur-|j|_|S | jd ur=|jd u r=| j|_|S | j|jkrI| j|_|S td)NzFCannot combine SpecifierSets with True and False prerelease overrides.)rT   r1   r   rU   r   r   rD   
ValueError)r   r#   r   r   r   r   __and__  s$   


	zSpecifierSet.__and__c                 C   s6   t |ttfrtt|}nt |tstS | j|jkS r.   )rT   r1   r8   r   rU   r   r$   r   r   r   r%     s
   
zSpecifierSet.__eq__c                 C   rQ   r.   )r   r   r   r   r   r   __len__  rS   zSpecifierSet.__len__c                 C   rQ   r.   )iterr   r   r   r   r   __iter__  rS   zSpecifierSet.__iter__c                 C   s.   | j d ur| j S | jsd S tdd | jD S )Nc                 s   s    | ]}|j V  qd S r.   r&   r   r   r   r   r     s    z+SpecifierSet.prereleases.<locals>.<genexpr>)rD   r   r   r   r   r   r   r&     s
   
zSpecifierSet.prereleasesr'   c                 C   ra   r.   r`   r(   r   r   r   r&     r_   r)   c                 C   rb   r.   rc   rd   r   r   r   re     rS   zSpecifierSet.__contains__c                    sL   t  ttfst  d u r| js jrdS t fdd| jD S )NFc                 3   s    | ]
}|j  d V  qdS )r   Nrc   r   r)   r&   r   r   r     s    z(SpecifierSet.contains.<locals>.<genexpr>)rT   r   r   r   r&   rg   allr   r*   r   r   r   r+     s   
zSpecifierSet.containsr,   c                 C   s   |d u r| j }| jr| jD ]}|j|t|d}q|S g }g }|D ](}t|ttfs/t|}n|}t|tr7q!|jrD|sD|sC|	| q!|	| q!|sT|rT|d u rT|S |S )Nr   )
r&   r   r-   r4   rT   r   r   r   rg   ri   )r   r,   r&   r<   filteredrk   r)   rm   r   r   r   r-     s,   




zSpecifierSet.filterrn   r.   )r   r   r   r1   r   r4   rF   rN   r    r2   r"   r   r   r3   r%   r   r   r8   r   rp   r&   r6   rr   re   r+   r   r   r-   r   r   r   r   r   l  sJ    
	
r   )+r/   r   r   r   r   typingr   r   r   r   r   r   r   r	   r
   r   r   utilsr   r?   r   r   r   rs   r1   rr   r   r4   rq   r   r   ABCMetar   r8   rt   r   r   r   r   r   r   r   r   r   r   r   r   <module>   s<   43 
<
  
.