a
    <BìjuŸ  ã                   @  sP  d Z ddlm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 ddlmZ ddlmZmZ eeef Zeded	�Zeeegef Zd
ddœdd„Zdddœdd„Zdddœdd„ZG dd„ deƒZG dd„ dejd�ZG dd„ deƒZe d¡Z dddœdd„Z!ddd œd!d"„Z"dd#d$œd%d&„Z#ddd'd(œd)d*„Z$G d+d,„ d,eƒZ%dS )-z¢
.. testsetup::

    from pip._vendor.packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
    from pip._vendor.packaging.version import Version
é    )ÚannotationsN)ÚCallableÚFinalÚIterableÚIteratorÚTypeVarÚUnioné   )Úcanonicalize_version)ÚInvalidVersionÚVersionÚUnparsedVersionVar)ÚboundÚUnparsedVersionúVersion | None©ÚversionÚreturnc                 C  s0   t | tƒs,zt| ƒ} W n ty*   Y d S 0 | S ©N)Ú
isinstancer   r   ©r   © r   ú_/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pip/_vendor/packaging/specifiers.pyÚ_coerce_version   s    
r   r   c                 C  s   | j d d�S )N)Úlocal©Z__replace__r   r   r   r   Ú_public_version#   s    r   c                 C  s   | j d d d d d�S )N)ÚpreÚpostÚdevr   r   r   r   r   r   Ú_base_version'   s    r    c                   @  s   e Zd ZdZdS )Ú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   r!   +   s   r!   c                   @  sÆ   e Zd ZdZdZeddœdd„ƒZejddœdd„ƒZ	ejd	dœd
d„ƒZ
ejdddœdd„ƒZeejddœdd„ƒƒZejdddœdd„ƒZejd ddddœdd„ƒZejd!ddddœdd„ƒZdS )"ÚBaseSpecifierr   )Ú_strÚstr©r   c                 C  s   t | ƒS )z Internal property for match_args©r(   ©Úselfr   r   r   r'   ;   s    zBaseSpecifier._strc                 C  s   dS )zŽ
        Returns the str representation of this Specifier-like object. This
        should be representative of the Specifier itself.
        Nr   r+   r   r   r   Ú__str__@   s    zBaseSpecifier.__str__Úintc                 C  s   dS )zF
        Returns a hash value for this Specifier-like object.
        Nr   r+   r   r   r   Ú__hash__G   s    zBaseSpecifier.__hash__ÚobjectÚbool©Úotherr   c                 C  s   dS )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,   r3   r   r   r   Ú__eq__M   s    zBaseSpecifier.__eq__úbool | Nonec                 C  s   dS )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+   r   r   r   ÚprereleasesV   s    zBaseSpecifier.prereleasesÚNone©Úvaluer   c                 C  s   dS )zQSetter for :attr:`prereleases`.

        :param value: The value to set.
        Nr   ©r,   r:   r   r   r   r7   _   s    N©Úitemr7   r   c                 C  s   dS )zR
        Determines if the given item is contained within this specifier.
        Nr   ©r,   r=   r7   r   r   r   Úcontainsf   s    zBaseSpecifier.containsúIterable[UnparsedVersionVar]úIterator[UnparsedVersionVar]©Úiterabler7   r   c                 C  s   dS )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,   rC   r7   r   r   r   Úfilterl   s    zBaseSpecifier.filter)N)N)r"   r#   r$   Ú	__slots__Z__match_args__Úpropertyr'   ÚabcÚabstractmethodr-   r/   r5   r7   Úsetterr?   rD   r   r   r   r   r&   7   s(    ÿr&   )Ú	metaclassc                	   @  s   e Zd ZU dZdZdZdZe de e d ej	ej
B ¡Zdddd	d
ddddœZded< d\ddddœdd„Zdddœdd„Zdddœdd„Zedd œd!d"„ƒZejddd#œd$d"„ƒZedd œd%d&„ƒZedd œd'd(„ƒZdd œd)d*„Zdd œd+d,„Zed-d œd.d/„ƒZd0d œd1d2„Zd3d4d5œd6d7„Zdd8d9œd:d;„Zddd4d<œd=d>„Zddd4d<œd?d@„Zddd4d<œdAdB„Zddd4d<œdCdD„Zddd4d<œdEdF„Z ddd4dGœdHdI„Z!ddd4dGœdJdK„Z"dLdd4d<œdMdN„Z#dOd4dPœdQdR„Z$d]dSdd4dTœdUdV„Z%d^dWddXdYœdZd[„Z&dS )_Ú	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).
    )Ú_prereleasesÚ_specÚ_spec_versionz8
        (?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*Ú
compatibleÚequalÚ	not_equalÚless_than_equalÚgreater_than_equalÚ	less_thanÚgreater_thanÚ	arbitrary)ú~=ú==ú!=z<=ú>=ú<ú>ú===r   Ú
_operatorsÚ Nr(   r6   r8   )Úspecr7   r   c                 C  sL   | j  |¡}|std|›�ƒ‚| d¡ ¡ | d¡ ¡ f| _|| _d| _dS )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).
        zInvalid specifier: Úoperatorr   N)Ú_regexÚ	fullmatchr!   ÚgroupÚstriprM   rL   rN   )r,   r`   r7   Úmatchr   r   r   Ú__init__ó   s    þzSpecifier.__init__r   r   c                 C  sD   | j dur"| j d |kr"| j d S t|ƒ}|du r6dS ||f| _ |S )zDOne element cache, as only one spec Version is needed per Specifier.Nr   r	   )rN   r   )r,   r   Zversion_specifierr   r   r   Ú_get_spec_version  s    

zSpecifier._get_spec_versionr   c                 C  s   |   |¡}|dusJ ‚|S )zÕGet spec version, asserting it's valid (not for === operator).

        This method should only be called for operators where version
        strings are guaranteed to be valid PEP 440 versions (not ===).
        N)rh   )r,   r   Úspec_versionr   r   r   Ú_require_spec_version  s    
zSpecifier._require_spec_versionr)   c                 C  s\   | j d ur| j S | j\}}|dkrX|dkr8| d¡r8dS |  |¡}|d u rNd S |jrXdS dS )NrY   rX   ú.*FT)rL   rM   Úendswithrh   Úis_prerelease)r,   ra   Úversion_strr   r   r   r   r7   %  s    


zSpecifier.prereleasesr9   c                 C  s
   || _ d S r   ©rL   r;   r   r   r   r7   B  s    c                 C  s
   | j d S )z`The operator of this specifier.

        >>> Specifier("==1.2.3").operator
        '=='
        r   ©rM   r+   r   r   r   ra   F  s    zSpecifier.operatorc                 C  s
   | j d S )zaThe version of this specifier.

        >>> Specifier("==1.2.3").version
        '1.2.3'
        r	   rp   r+   r   r   r   r   O  s    zSpecifier.versionc                 C  s8   | j durd| j›�nd}d| jj› dt| ƒ›|› 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=r_   r[   ú(ú)>)rL   r7   Ú	__class__r"   r(   ©r,   r   r   r   r   Ú__repr__X  s
    ÿýzSpecifier.__repr__c                 C  s   dj | 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{}{})ÚformatrM   r+   r   r   r   r-   j  s    zSpecifier.__str__ztuple[str, str]c                 C  sF   | j \}}|dks| d¡r$||fS |  |¡}t||dkd�}||fS )Nr]   rk   rW   ©Zstrip_trailing_zero)rM   rl   rj   r
   )r,   ra   r   ri   Zcanonical_versionr   r   r   Ú_canonical_spect  s    

ÿzSpecifier._canonical_specr.   c                 C  s
   t | jƒS r   )Úhashry   r+   r   r   r   r/   ‚  s    zSpecifier.__hash__r0   r1   r2   c                 C  sR   t |tƒr6z|  t|ƒ¡}W qF ty2   t Y S 0 nt || jƒsFt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(   rt   r!   ÚNotImplementedry   r4   r   r   r   r5   …  s    
zSpecifier.__eq__ÚCallableOperator)Úopr   c                 C  s   t | d| j| › �ƒ}|S )NZ	_compare_)Úgetattrr^   )r,   r}   Úoperator_callabler   r   r   Ú_get_operator¢  s    ÿzSpecifier._get_operator)Úprospectiver`   r   c                 C  sH   t tt tt|ƒ¡ƒd d… ƒ}|d7 }|  d¡||ƒoF|  d¡||ƒS )Néÿÿÿÿrk   rZ   rX   )Ú_version_joinÚlistÚ	itertoolsÚ	takewhileÚ_is_not_suffixÚ_version_splitr€   )r,   r�   r`   Úprefixr   r   r   Ú_compare_compatible¨  s    	ÿÿzSpecifier._compare_compatiblec                 C  sˆ   |  d¡rdtt|ƒdd�}t|d d… dd�}t|ƒ}t|ƒ}t||ƒ\}}|d t|ƒ… }	|	|kS |  |¡}
|
js|t|ƒ}||
kS d S )Nrk   Frx   éþÿÿÿ)rl   r
   r   rˆ   Ú_pad_versionÚlenrj   r   )r,   r�   r`   Znormalized_prospectiveZnormalized_specÚ
split_specÚsplit_prospectiveÚpadded_prospectiveÚ_Úshortened_prospectiveri   r   r   r   Ú_compare_equal¼  s    
ÿ
zSpecifier._compare_equalc                 C  s   |   ||¡ S r   )r“   ©r,   r�   r`   r   r   r   Ú_compare_not_equalä  s    zSpecifier._compare_not_equalc                 C  s   t |ƒ|  |¡kS r   ©r   rj   r”   r   r   r   Ú_compare_less_than_equalç  s    z"Specifier._compare_less_than_equalc                 C  s   t |ƒ|  |¡kS r   r–   r”   r   r   r   Ú_compare_greater_than_equalí  s    z%Specifier._compare_greater_than_equal)r�   Úspec_strr   c                 C  s:   |   |¡}||k sdS |js6|jr6t|ƒt|ƒkr6dS dS ©NFT)rj   rm   r    ©r,   r�   r™   r`   r   r   r   Ú_compare_less_thanó  s    
ÿþýzSpecifier._compare_less_thanc                 C  sX   |   |¡}||ksdS |js6|jr6t|ƒt|ƒkr6dS |jd urTt|ƒt|ƒkrTdS dS rš   )rj   Úis_postreleaser    r   r›   r   r   r   Ú_compare_greater_than  s"    
ÿþýÿþzSpecifier._compare_greater_thanzVersion | strc                 C  s   t |ƒ ¡ t |ƒ ¡ kS r   )r(   Úlowerr”   r   r   r   Ú_compare_arbitrary0  s    zSpecifier._compare_arbitraryzstr | Version©r=   r   c                 C  s
   |   |¡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")
        True
        >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True)
        True
        ©r?   ©r,   r=   r   r   r   Ú__contains__3  s    zSpecifier.__contains__r   r<   c                 C  s   t t| j|g|d�ƒƒS )as  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 will follow the recommendation from
            :pep:`440` and match prereleases, as there are no other versions.

        >>> 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")
        True
        >>> Specifier(">=1.2.3", prereleases=False).contains("1.3.0a1")
        False
        >>> Specifier(">=1.2.3").contains("1.3.0a1")
        True
        ©r7   )r1   r„   rD   r>   r   r   r   r?   H  s    zSpecifier.containsr@   rA   rB   c           	      c  sÂ   g }d}|dur|n| j }|  | j¡}|D ]r}t|ƒ}|du r^| jdkrœ|  || j¡rœ|V  q*||| jƒr*|jrt|r€d}|V  q*|du r*| jdur*| |¡ q*|s¾|du r¾| jdur¾|E dH  dS )a  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 follow the recommendation from :pep:`440`
            and match prereleases if there are no other versions.

        >>> 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']
        FNr]   T)	r7   r€   ra   r   r    r   rm   rL   Úappend)	r,   rC   r7   Zprereleases_versionsZfound_non_prereleasesZinclude_prereleasesr   r   Úparsed_versionr   r   r   rD   c  s2    ÿÿ
ÿþýzSpecifier.filter)r_   N)N)N)'r"   r#   r$   r%   rE   Z_operator_regex_strZ_version_regex_strÚreÚcompileÚVERBOSEÚ
IGNORECASErb   r^   Ú__annotations__rg   rh   rj   rF   r7   rI   ra   r   rv   r-   ry   r/   r5   r€   rŠ   r“   r•   r—   r˜   rœ   rž   r    r¤   r?   rD   r   r   r   r   rK   v   s^   
	^
þø

(" ÿrK   z([0-9]+)((?:a|b|c|rc)[0-9]+)r(   z	list[str]c                 C  s^   g }|   d¡\}}}| |pd¡ | d¡D ],}t |¡}|rN| | ¡ ¡ q,| |¡ q,|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_regexrc   ÚextendÚgroups)r   ÚresultÚepochr‘   Úrestr=   rf   r   r   r   rˆ   ¥  s    
rˆ   )Ú
componentsr   c                 C  s   | ^}}|› dd  |¡› �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·   r   r   r   rƒ   »  s    rƒ   r1   )Úsegmentr   c                   s   t ‡ fdd„dD ƒƒ S )Nc                 3  s   | ]}ˆ   |¡V  qd S r   )Ú
startswith)Ú.0r‰   ©rº   r   r   Ú	<genexpr>Ç  s   z!_is_not_suffix.<locals>.<genexpr>)r   ÚaÚbÚrcr   )Úanyr½   r   r½   r   r‡   Æ  s    ÿr‡   ztuple[list[str], list[str]])ÚleftÚrightr   c              
   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   |   ¡ S r   ©Úisdigit©Úxr   r   r   Ú<lambda>Ð  ó    z_pad_version.<locals>.<lambda>c                 S  s   |   ¡ S r   rÅ   rÇ   r   r   r   rÉ   Ñ  rÊ   r   r	   r®   )	r¦   r„   r…   r†   r�   ÚinsertÚmaxÚchainÚfrom_iterable)rÃ   rÄ   Ú
left_splitÚright_splitr   r   r   rŒ   Ì  s    
,,þrŒ   c                   @  sð   e Zd ZdZdZd1ddddœd	d
„Zeddœdd„ƒZejdddœdd„ƒZddœdd„Z	ddœdd„Z
ddœdd„Zdd dœdd„Zdddœdd„Zddœd d!„Zd"dœd#d$„Zd%dd&œd'd(„Zd2d%dddd)œd*d+„Zd3d,dd-d.œd/d0„ZdS )4Ú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.
    )rL   Ú_specsr_   Nzstr | Iterable[Specifier]r6   r8   )Ú
specifiersr7   r   c                 C  sD   t |tƒr0dd„ | d¡D ƒ}ttt|ƒƒ| _n
t|ƒ| _|| _dS )a´  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.
            May also be an iterable of ``Specifier`` instances, which will be used
            as is.
        :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                 S  s   g | ]}|  ¡ r|  ¡ ‘qS r   )re   ©r¼   Úsr   r   r   Ú
<listcomp>  rÊ   z)SpecifierSet.__init__.<locals>.<listcomp>ú,N)r   r(   r±   Ú	frozensetÚmaprK   rÒ   rL   )r,   rÓ   r7   Úsplit_specifiersr   r   r   rg   ê  s
    

zSpecifierSet.__init__r)   c                 C  s6   | j d ur| j S | jsd S tdd„ | jD ƒƒr2dS d S )Nc                 s  s   | ]}|j V  qd S r   r¥   rÔ   r   r   r   r¾     rÊ   z+SpecifierSet.prereleases.<locals>.<genexpr>T)rL   rÒ   rÂ   r+   r   r   r   r7     s    
zSpecifierSet.prereleasesr9   c                 C  s
   || _ d S r   ro   r;   r   r   r   r7   $  s    r(   c                 C  s.   | j durd| j›�nd}dt| ƒ›|› 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)>
        Nrq   r_   z<SpecifierSet(rs   )rL   r7   r(   ru   r   r   r   rv   (  s
    ÿýzSpecifierSet.__repr__c                 C  s   d  td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                 s  s   | ]}t |ƒV  qd S r   r*   rÔ   r   r   r   r¾   H  rÊ   z'SpecifierSet.__str__.<locals>.<genexpr>)r¹   ÚsortedrÒ   r+   r   r   r   r-   =  s    zSpecifierSet.__str__r.   c                 C  s
   t | jƒS r   )rz   rÒ   r+   r   r   r   r/   J  s    zSpecifierSet.__hash__zSpecifierSet | strr2   c                 C  sŽ   t |tƒrt|ƒ}nt |tƒs"tS tƒ }t| j|jB ƒ|_| jdu rX|jdurX|j|_n2| jdurl|jdu sx| j|jkr‚| j|_nt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Ò   rL   Ú
ValueError)r,   r3   Ú	specifierr   r   r   Ú__and__M  s&    




ÿÿ
þ
ÿzSpecifierSet.__and__r0   r1   c                 C  s6   t |ttfƒrtt|ƒƒ}nt |tƒs*t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(   rK   rÑ   r{   rÒ   r4   r   r   r   r5   l  s
    
zSpecifierSet.__eq__c                 C  s
   t | jƒS )z7Returns the number of specifiers in this specifier set.)r�   rÒ   r+   r   r   r   Ú__len__†  s    zSpecifierSet.__len__zIterator[Specifier]c                 C  s
   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+   r   r   r   Ú__iter__Š  s    zSpecifierSet.__iter__r   r¡   c                 C  s
   |   |¡S )aq  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")
        True
        >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)
        True
        r¢   r£   r   r   r   r¤   ”  s    zSpecifierSet.__contains__)r=   r7   Ú	installedr   c                 C  sF   t |ƒ}|dur|r|jrd}|du r*|n|}tt| j|g|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 will follow the recommendation from :pep:`440`
            and match prereleases, as there are no other versions.
        :param installed:
            Whether or not the item is installed. If set to ``True``, it will
            accept prerelease versions even if the specifier does not allow them.

        >>> 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")
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False).contains("1.3.0a1")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True)
        True
        NTr¥   )r   rm   r1   r„   rD   )r,   r=   r7   râ   r   Z
check_itemr   r   r   r?   ©  s
     zSpecifierSet.containsr@   rA   rB   c           	        sì   |du r| j dur| j }| jrV| jD ]}|j||du r:dn|d�}q$|dur€t|ƒS n*|du rft|ƒS |du r€‡ fdd„|D ƒS g }g }d}|D ]J}t|ƒ}|du rº| |¡ | |¡ q�|jrÌ| |¡ q�| |¡ d}q�t|ræ|n|ƒ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 follow the recommendation from :pep:`440`
            and match prereleases if there are no other versions.

        >>> 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"]))
        ['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']
        NTr¥   Fc                 3  s(   | ] }t |ƒ ‰ d u sˆ js|V  qd S r   )r   rm   )r¼   r=   r   r   r   r¾     s   ýz&SpecifierSet.filter.<locals>.<genexpr>)r7   rÒ   rD   rà   r   r¦   rm   )	r,   rC   r7   r`   Zfiltered_itemsÚfound_prereleasesZfound_final_releaser=   r§   r   r   r   rD   Ñ  s8    '
ÿ

þ	

zSpecifierSet.filter)r_   N)NN)N)r"   r#   r$   r%   rE   rg   rF   r7   rI   rv   r-   r/   rÞ   r5   rß   rá   r¤   r?   rD   r   r   r   r   rÑ   á  s,     ý&
  ü) ÿrÑ   )&r%   Ú
__future__r   rG   r…   r¨   Útypingr   r   r   r   r   r   Úutilsr
   r   r   r   r(   r   r   r1   r|   r   r   r    rÜ   r!   ÚABCMetar&   rK   r©   r²   rˆ   rƒ   r‡   rŒ   rÑ   r   r   r   r   Ú<module>   s4    	?    0
