o �J�h��@s\ddlZddlZddlZdd�ZGdd�de�ZejGdd�de��ZejGdd �d e��ZGd d�de�Z Gdd �d e�Z dd�Zdd�Zdd�Z dZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd �d e�ZGd!d"�d"e�ZGd#d$�d$e�ZejGd%d&�d&e��ZGd'd(�d(e�ZeZejGd)d*�d*e��ZdS)+�NcCs |o|ddko|��o|dkS)Nr�0)�isdigit��value�r�SC:\pinokio\api\whisper-webui.git\app\env\lib\site-packages\semantic_version\base.py�_has_leading_zero s ��rc@� eZdZgZdd�Zdd�ZdS)� MaxIdentifiercC�dS)NzMaxIdentifier()r��selfrrr�__repr__�zMaxIdentifier.__repr__cC�t||j�S�N�� isinstance� __class__�r �otherrrr�__eq__�zMaxIdentifier.__eq__N)�__name__� __module__�__qualname__� __slots__rrrrrrr sr c@�2eZdZdgZdd�Zdd�Zdd�Zdd �Zd S)�NumericIdentifierrcCst|�|_dSr)�intr�r rrrr�__init__�zNumericIdentifier.__init__cC� d|jS)NzNumericIdentifier(%r)rrrrrr"� zNumericIdentifier.__repr__cC�t|t�r|j|jkStSr)rrr�NotImplementedrrrrr%� zNumericIdentifier.__eq__cCs6t|t�rdSt|t�rdSt|t�r|j|jkStS�NT)rr �AlphaIdentifierrrr&rrrr�__lt__*� zNumericIdentifier.__lt__N�rrrrr!rrr*rrrrr�rc@r)r)rcCs|�d�|_dS)N�ascii)�encoderr rrrr!9�zAlphaIdentifier.__init__cCr#)NzAlphaIdentifier(%r)rrrrrr<r$zAlphaIdentifier.__repr__cCr%r)rr)rr&rrrrr?r'zAlphaIdentifier.__eq__cCs6t|t�rdSt|t�rdSt|t�r|j|jkStS)NTF)rr rr)rr&rrrrr*Dr+zAlphaIdentifier.__lt__Nr,rrrrr)5r-r)c@seZdZe�d�Ze�d�Z d4dd�Zed5dd��Z d d �Z dd�Zd d�Zd6dd�Z ed5dd��Zed7dd��Zed5dd��Zedd��Zdd�Zdd�Zdd�Zd d!�Zd5d"d#�Zed$d%��Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�ZdS)8�VersionzB^(\d+)\.(\d+)\.(\d+)(?:-([0-9a-zA-Z.-]+))?(?:\+([0-9a-zA-Z.-]+))?$zL^(\d+)(?:\.(\d+)(?:\.(\d+))?)?(?:-([0-9a-zA-Z.-]*))?(?:\+([0-9a-zA-Z.-]*))?$NFc Cs�|r tjdtdd�|du}||uo&|uo&|uo&|uo&dun} || As2td��|r@|�||�\}}}}}nt|pDd�}|sNt|pLd�}|�||||||�||_||_||_ ||_ ||_||_|j dd�|_|j dd�|_dS) NzIPartial versions will be removed in 3.0; use SimpleSpec('1.x.x') instead.�� stacklevelz6Call either Version('1.2.3') or Version(major=1, ...).rF)� with_buildT)�warnings�warn�DeprecationWarning� ValueError�parse�tuple�_validate_kwargs�major�minor�patch� prerelease�build�partial�_build_precedence_key�_cmp_precedence_key�_sort_precedence_key) r �version_stringr=r>r?r@rArBZhas_textZ has_partsrrrr!Ts0 �8zVersion.__init__cCs|dur|r|St|�Sr)r)�clsr� allow_nonerrr�_coerceszVersion._coercecCsN|jr|j|jkrdkrnn t|jdd|jd�St|jddd|jd�S�Nr�r=r>r?rB�)r@r>r?r1r=rBrrrr� next_major�s"��zVersion.next_majorcCs@|jr|jdkrt|j|jd|jd�St|j|jdd|jd�SrJ)r@r?r1r=r>rBrrrr� next_minor�s��zVersion.next_minorcCs:|jrt|j|j|j|jd�St|j|j|jd|jd�S)NrKrL)r@r1r=r>r?rBrrrr� next_patch�s��zVersion.next_patchr?cCs�|dkr|S|dkrt|j|j|j|j|jd�S|dkr(t|j|j|j|jd�S|dkr<t|j|j|jr6dnd|jd�S|d krTt|j|jrHdnd|jrNdnd|jd�Std |��)z@Return a new Version object, truncated up to the selected level.rAr@)r=r>r?r@rBr?rKr>Nrr=zInvalid truncation level `%s`.)r1r=r>r?r@rBr9)r �levelrrr�truncate�s@��zVersion.truncatec Cs�t�d�}|�|�}|std|��|d|��}|s.|�d�dkr.|d7}|�d�dks#d�dd�|�d�D��}|��t|�krIt ||d �S||��d�}t� d d|�}|dd krgd}|dd�}n@|ddkrvd}|dd�}n1|ddkr�|dd�}d |vr�|�d d�\}}n|d}}nd |vr�|�d d�\}}n|d}}|�d d�}|r�d||f}|r�d||f}|||d �S)a�Coerce an arbitrary version string into a semver-compatible one. The rule is: - If not enough components, fill minor/patch with zeroes; unless partial=True - If more than 3 dot-separated components, extra components are "build" data. If some "build" data already appeared, append it to the extra components Examples: >>> Version.coerce('0.1') Version(0, 1, 0) >>> Version.coerce('0.1.2.3') Version(0, 1, 2, (), ('3',)) >>> Version.coerce('0.1.2.3+4') Version(0, 1, 2, (), ('3', '4')) >>> Version.coerce('0.1+2-3+4_5') Version(0, 1, 0, (), ('2-3', '4-5')) z^\d+(?:\.\d+(?:\.\d+)?)?z.Version string lacks a numerical component: %rN�.r2z.0css�|] }|�d�p dVqdS)rN)�lstrip��.0�partrrr� <genexpr>�s �� z!Version.coerce.<locals>.<genexpr>�rBz[^a-zA-Z0-9+.-]�-r�+�rL�%s-%s�%s+%s)�re�compile�matchr9�end�count�join�split�lenr1�sub�replace) rGrFrBZbase_rer`�version�restr@rArrr�coerce�sP �� zVersion.coercecCsL|std|��|r|j}n|j}|�|�}|std|��|��\}}}} } t|�r1td|��t|�r;td|��t|�rEtd|��t|�}|�||�}|�||�}| duri|rf| durf|||ddfSd} n| dkrpd} nt| � d ��} |j | d d�| dur�|r�d} nd} n| dkr�d} nt| � d ��} |j | dd�|||| | fS) ahParse a version string into a tuple of components: (major, minor, patch, prerelease, build). Args: version_string (str), the version string to parse partial (bool), whether to accept incomplete input coerce (bool), whether to try to map the passed in string into a valid Version. z Invalid empty version string: %rzInvalid version string: %rz!Invalid leading zero in major: %rz!Invalid leading zero in minor: %rz!Invalid leading zero in patch: %rNrr[rRF��allow_leading_zeroesT)r9�partial_version_re� version_rer`�groupsrrrIr;rd�_validate_identifiers)rGrFrBrjrnr`r=r>r?r@rArrrr:)sF z Version.parsecCsT|D]%}|std|d�|�f��|ddkr'|��r'|dkr'|s'td|��qdS)Nz!Invalid empty identifier %r in %rrRrrz%Invalid leading zero in identifier %r)r9rcr)rGZidentifiersrl�itemrrrrpfs�� zVersion._validate_identifierscCs�|t|�ks"||�||�ks"||�||�ks"|dur|r"|dur.|s.td||||||f��|dur9|j|dd�|durF|j|dd�dSdS)Nz[Invalid kwargs to Version(major=%r, minor=%r, patch=%r, prerelease=%r, build=%r, partial=%rFrkT)rrIr9rp)rGr=r>r?r@rArBrrrr<rs ��zVersion._validate_kwargscC�t|j|j|j|j|jf�Sr)�iterr=r>r?r@rArrrr�__iter__�szVersion.__iter__cCs�d|j}|jdurd||jf}|jdurd||jf}|js-|jr7|jdkr7|jdur7d|d�|j�f}|jsB|jrL|jdkrLd|d�|j�f}|S)Nz%dz%s.%drr\rRr])r=r>r?r@rBrArc�r rhrrr�__str__�s zVersion.__str__cCs$d|jjt|�|jrdfSdfS)Nz%s(%r%s)z, partial=Truer[)rr�strrBrrrrr�s��zVersion.__repr__cCrrr)�hashr=r>r?r@rArrrr�__hash__�szVersion.__hash__cCsf|jrtdd�|jD��}nt�f}|s|j|j|j|fStdd�|jp%dD��}|j|j|j||fS)z�Build a precedence key. The "build" component should only be used when sorting an iterable of versions. cs�(�|]}|��rt|�nt|�VqdSr�rrr)rTrrrrW�� z0Version._build_precedence_key.<locals>.<genexpr>csrzrr{rTrrrrW�r|r)r@r;r r=r>r?rA)r r5Zprerelease_keyZ build_keyrrrrC�s* ��zVersion._build_precedence_keycC�|jSr)rErrrr�precedence_key�szVersion.precedence_keycCs8t||j�stS||krdS||krdS||krdStS)N��rLr)rrr&rrrr�__cmp__�szVersion.__cmp__cCs\t||j�stS|j|jko-|j|jko-|j|jko-|jpd|jp"dko-|jp(d|jp,dkS)Nr)rrr&r=r>r?r@rArrrrr�s � ��zVersion.__eq__cCs t||j�stSt|�t|�kSr)rrr&r;rrrr�__ne__�szVersion.__ne__cCst||j�stS|j|jkSr�rrr&rDrrrrr*��zVersion.__lt__cCst||j�stS|j|jkSrr�rrrr�__le__�r�zVersion.__le__cCst||j�stS|j|jkSrr�rrrr�__gt__�r�zVersion.__gt__cCst||j�stS|j|jkSrr�rrrr�__ge__�r�zVersion.__ge__)NNNNNNF)F)r?)FF) rrrr^r_rnrmr!�classmethodrIrMrNrOrQrjr:rpr<rtrvrryrC�propertyr~r�rr�r*r�r�r�rrrrr1OsN �+ $O< % r1c@s�eZdZdZdZdZdZdZdZdZ dZ d Zd ZdZ dZd Zeee eiZe�d�Zd!dd�Zedd��Zedd��Zdd�Zdd�Zdd�Zdd�Zdd�Zd S)"�SpecItemzA requirement specification.�*�<�<=�==�=r[�>=�>�!=�^�~�~=z$^(<|<=||=|==|>=|>|!=|\^|~|~=)(\d.*)$TcCs>|r tjdtdd�|�|�\}}||_||_t|�j|_dS)Nz,The `SpecItem` class will be removed in 3.0.r2r3) r6r7r8r:�kind�spec�Spec�clause�_clause)r �requirement_string�_warnr�r�rrrr!s�zSpecItem.__init__cCs�|std|��|dkr|jdfS|j�|�}|std|��|��\}}||jvr/|j|}t|dd�}|jdurH||j|j fvrHtd|��||fS)Nz+Invalid empty requirement specification: %rr�r[z%Invalid requirement specification: %rTrXzEInvalid requirement specification %r: build numbers have no ordering.) r9�KIND_ANY�re_specr`ro�KIND_ALIASESr1rA� KIND_EQUAL�KIND_NEQ)rGr�r`r�rhr�rrrr:s$ ��zSpecItem.parsecCsR|t�kr|ddd�S|t�kr|ddd�St|t�r'|d|j|jfdd�SdS)Nr�F)r�z<0.0.0-�%s%s)�Always�Neverr�Range�operator�target)rGZmatcherrrr�from_matcher8s �zSpecItem.from_matchercC�|j�|�Sr)r�r`rurrrr`ArzSpecItem.matchcC�d|j|jfS�Nr��r�r�rrrrrvDr0zSpecItem.__str__cCr�)Nz<SpecItem: %s %r>r�rrrrrGr0zSpecItem.__repr__cCs&t|t�stS|j|jko|j|jkSr)rr�r&r�r�rrrrrJs zSpecItem.__eq__cCst|j|jf�Sr)rxr�r�rrrrryOr0zSpecItem.__hash__N)T)rrr�__doc__r�ZKIND_LTZKIND_LTEr�ZKIND_SHORTEQZ KIND_EMPTYZKIND_GTEZKIND_GTr�Z KIND_CARETZ KIND_TILDEZKIND_COMPATIBLEr�r^r_r�r!r�r:r�r`rvrrryrrrrr��s8� r�cCst|��t|��Sr)r1r�)�v1�v2rrr�compareS�r�cCst|��t|��Sr)r�r`r1)r�rhrrrr`Wr�r`cCs&zt�|�WdStyYdSw)z;Validates a version string againt the SemVer specification.TF)r1r:r9)rFrrr�validate[s �r��simplecs�eZdZdZiZedd��Z�fdd�Zeefdd��Z edd ��Z d d�Zdd �Zdd�Z dd�Zdd�Zdd�Zdd�Zdd�Z�ZS)�BaseSpeca'A specification of compatible versions. Usage: >>> Spec('>=1.0.0', syntax='npm') A version matches a specification if it matches any of the clauses of that specification. Internally, a Spec is AnyOf( AllOf(Matcher, Matcher, Matcher), AllOf(...), ) cCsF|j}|durtd��||jvrtd||j||f��||j|<|S)Nz(A Spec needs its SYNTAX field to be set.zDuplicate syntax for %s: %r, %r)�SYNTAXr9�SYNTAXES)rG�subclass�syntaxrrr�register_syntaxws �� zBaseSpec.register_syntaxcs$tt|��||_|�|�|_dSr)�superr�r!� expression�_parse_to_clauser�)r r��rrrr!�szBaseSpec.__init__cCs|j||�S)z>Convert a syntax-specific expression into a BaseSpec instance.)r�)rGr�r�rrrr:�szBaseSpec.parsecC�t��)z#Converts an expression to a clause.��NotImplementedError�rGr�rrrr��szBaseSpec._parse_to_clauseccs �|D] }|�|�r |VqdS)z3Filter an iterable of versions satisfying the Spec.N�r`)r �versionsrhrrr�filter�s� ��zBaseSpec.filtercCr�)z+Check whether a Version satisfies the Spec.)r�r`rurrrr`��zBaseSpec.matchcCst|�|��}|r t|�SdS)z@Select the best compatible version among an iterable of options.N)�listr��max)r r��optionsrrr�select�szBaseSpec.selectcCst|t�r |�|�SdS)zWhether `version in self`.F)rr1r`rurrr�__contains__�s zBaseSpec.__contains__cCst||j�stS|j|jkSr)rrr&r�rrrrr�szBaseSpec.__eq__cC� t|j�Sr)rxr�rrrrry�r$zBaseSpec.__hash__cCr}r)r�rrrrrv��zBaseSpec.__str__cCsd|jj|jfS)Nz<%s: %r>)rrr�rrrrr�r�zBaseSpec.__repr__)rrrr�r�r�r�r!�DEFAULT_SYNTAXr:r�r�r`r�r�rryrvr� __classcell__rrr�rr�gs$ r�c@sReZdZgZdd�Zdd�Zdd�Zdd�Zdd d�Zdd �Z dd�Z dd�ZdS)�ClausecCr�rr�rurrrr`�r�zClause.matchcCr�rr�rrrr�__and__�r�zClause.__and__cCr�rr�rrrr�__or__�r�z Clause.__or__cCr�rr�rrrrr�r�z Clause.__eq__� cCsd�|��d|�S)z!Pretty-print the clause. � r�)rc�_prettyrg)r �indentrrr�prettyprint�szClause.prettyprintccs�t|�VdS)zvActual pretty-printing logic. Yields: A list of string. Indentation is performed with . N��reprrrrrr��s�zClause._prettycCs ||kSrrrrrrr��r$z Clause.__ne__cC�|Srrrrrr�simplify�rzClause.simplifyN)r�)rrrrr`r�r�rr�r�r�r�rrrrr��s r�c�jeZdZdgZ�fdd�Zdd�Zdd�Zdd �Zd d�Zdd �Z dd�Z dd�Zdd�Zdd�Z �ZS)�AnyOf�clausesc�tt|��t|�|_dSr)r�r�r!� frozensetr��r r�r�rrr!��zAnyOf.__init__c�t�fdd�|jD��S)Nc3��|]}|��VqdSrr��rU�c�rhrrrW��zAnyOf.match.<locals>.<genexpr>)�anyr�rurr�rr`��zAnyOf.matchcC�bt�}|jD]}|��}t|t�r||jO}q|t�krq|�|�qt|�dkr-|��St|�S�NrL) �setr�r�rr�r��addre�pop�r � subclausesr�� simplifiedrrrr�� zAnyOf.simplifycC�tt|jf�Sr)rxr�r�rrrrry�r"zAnyOf.__hash__cCr�r�rsr�rrrrrt�r$zAnyOf.__iter__cC�t||j�o|j|jkSr�rrr�rrrrr�r�zAnyOf.__eq__cC�4t|t�r ||@St|t�st|t�rt||�StSr�r�AllOf�Matcherr�r&rrrrr�� z AnyOf.__and__cCsVt|t�rt|j|jB�}t|�St|t�st|t�r)t|jt|g�B�}t|�StSr)rr�r�r�r�r�r�r&�r rr�rrrr�s ��zAnyOf.__or__cC�dd�tdd�|jD��S)Nz AnyOf(%s)�, cs��|]}t|�VqdSrr�r�rrrrW��z!AnyOf.__repr__.<locals>.<genexpr>�rc�sortedr�rrrrr�zAnyOf.__repr__cc�X�dV|jD]}t|��}|dd�D]}d|Vqd|ddVqdVdS)NzAnyOF(rr��,�)�r�r�r��r r��lines�linerrrr�� z AnyOf._pretty�rrrrr!r`r�ryrtrr�r�rr�r�rrr�rr��s r�cr�)r�r�cr�r)r�r�r!r�r�r�r�rrr!r�zAllOf.__init__cr�)Nc3r�rr�)rUr�r�rrrW$r�zAllOf.match.<locals>.<genexpr>)�allr�rurr�rr`#r�zAllOf.matchcCr�r�) r�r�r�rr�r�r�rer�r�rrrr�&r�zAllOf.simplifycCr�r)rxr�r�rrrrry4r"zAllOf.__hash__cCr�rr�rrrrrt7r$zAllOf.__iter__cCr�rr�rrrrr:r�zAllOf.__eq__cCsVt|t�s t|t�rt|jt|g�B�}t|�St|t�r)t|j|jB�}t|�StSr)rr�r�r�r�r�r�r&r�rrrr�=s ��z AllOf.__and__cCsBt|t�r ||BSt|t�rt|t|��St|t�rt||�StSr�rr�r�r�r&rrrrr�Fs zAllOf.__or__cCr�)Nz AllOf(%s)r�csr�rr�r�rrrrWQr�z!AllOf.__repr__.<locals>.<genexpr>rrrrrrPrzAllOf.__repr__ccr)NzAllOF(rr�rrrrrrrr�Sr z AllOf._prettyrrrr�rr�s r�c@r )r�cCr�rr�rrrrr�`r�zMatcher.__and__cCs4t|t�r ||BSt|t�st|t�rt||�StSrr rrrrr�hr�zMatcher.__or__N)rrrrr�r�rrrrr�]sr�c@�@eZdZgZdd�Zdd�Zdd�Zdd�Zd d �Zdd�Z d S)r�cCr)NFrrurrrr`trzNever.matchcC� ttf�Sr)rxr�rrrrrywr$zNever.__hash__cCrrrrrrrrzrzNever.__eq__cCr�rrrrrrr�}rz Never.__and__cC�|Srrrrrrr��rzNever.__or__cCr)NzNever()rrrrrr�rzNever.__repr__N� rrrrr`ryrr�r�rrrrrr�q�r�c@r)r�cCrr(rrurrrr`�rzAlways.matchcCrr)rxr�rrrrry�r$zAlways.__hash__cCrrrrrrrr�rz Always.__eq__cCrrrrrrrr��rzAlways.__and__cCr�rrrrrrr��rz Always.__or__cCr)NzAlways()rrrrrr�rzAlways.__repr__Nrrrrrr��rr�cs~eZdZdZdZdZdZdZdZdZ dZ d Zd ZdZ gd�Ze ef�fd d� Zdd�Zdd�Zdd�Zdd�Zdd�Z�ZS)r�r�r�r�r�r�r��alwaysZnaturalz same-patch�implicit�strict)r�r��prerelease_policy�build_policycsbtt|��|jr||j|jfvrtd||f��||_||_||_ |jr,|j |_dS||_dS)Nz3Invalid range %s%s: build numbers have no ordering.)r�r�r!rA�OP_EQ�OP_NEQr9r�r�r�BUILD_STRICTr)r r�r�rrr�rrr!�s��zRange.__init__cCs�|j|jkr|�d�}|jr!|j��|��k}|j|jkr!|s!dS|j|jkrD|j|jkr?|j�d�|�d�ko>|j |jj kS||jkS|j|j krO||jkS|j|jkrZ||jkS|j|jkr}|jrx|j|j krx|��|j��krx|jjsxdS||jkS|j|jkr�||jkS|j|jks�J�|j|jkr�|j�d�|�d�ko�|j |jj kS|jr�|j|j kr�|��|j��kr�|jjs�dS||jkS)Nr@F)rrrQr@r�r�PRERELEASE_SAMEPATCHr�rrA�OP_GT�OP_GTE�OP_LT�PRERELEASE_NATURAL�OP_LTEr)r rhZ same_patchrrrr`�sP � �� zRange.matchcCstt|j|j|jf�Sr)rxr�r�r�rrrrrry�szRange.__hash__cCs0t||j�o|j|jko|j|jko|j|jkSr)rrr�r�rrrrrr�s � � �zRange.__eq__cCr�r��r�r�rrrrrv�r0z Range.__str__cCsF|j|jkrdnd|j|j|jkrdnd|j}d|j|j|fS)Nr[z, prerelease_policy=%rz, build_policy=%rzRange(%r, %r%s))rrr�BUILD_IMPLICITr�r�)r Zpolicy_partrrrr�s��zRange.__repr__)rrrrrrrr r�PRERELEASE_ALWAYSrrr"rrr!r`ryrrvrr�rrr�rr��s&1r�c@�*eZdZdZedd��ZGdd�d�ZdS)� SimpleSpecr�cCr�r��Parserr:r�rrrr�r�zSimpleSpec._parse_to_clausec@steZdZdZe�djed�ej�Ze dd��Z dZdZdZ d Zd ZdZdZd ZdZeed�Zgd�Ze dd��ZdS)zSimpleSpec.Parserz\*|0|[1-9][0-9]*z�^ (?P<op><|<=||=|==|>=|>|!=|\^|~|~=) (?P<major>{nb})(?:\.(?P<minor>{nb})(?:\.(?P<patch>{nb}))?)? (?:-(?P<prerel>[a-z0-9A-Z.-]*))? (?:\+(?P<build>[a-z0-9A-Z.-]*))? $ )�nbcCsD|�d�}t�}|D]}|j�|�std|��||�|�M}q |S)NrzInvalid simple block %r)rdr�� NAIVE_SPECr`r9�parse_block)rGr��blocksr��blockrrrr:!s zSimpleSpec.Parser.parser�r�r�r�r�r�r�r�r�)r�r[�r��x�XNc Cs�|j�|�std|��|j�|��\}}}}}}|j�||�}||jvr(dnt|�}||jvr3dnt|�} ||jvr>dnt|�} |dur\tdddd�}||j |j fvr[td|��n/| durht|ddd�}n#| durtt|| dd�}nt|| | |r|�d�nd|r�|�d�ndd�}|dus�| dus�| dur�|s�|r�td|��|dur�||j |jfvr�td|��||j kr�|jr�|��}n|jr�|��}n|��}ttj|�ttj|�@S||jkr�|dus�J�| dur�|��}n|��}ttj|�ttj|�@S||jk�r(|du�s J�| du�s| du�r|��}n|��}ttj|�ttj|�@S||j k�rs|du�r9ttj|�S| du�rLttj|�ttj|��@S| du�r_ttj|�ttj|��@S|dk�rmttj|tjd �Sttj|�S||jk�r�|du�s�J�| du�r�ttj|�ttj|��BS| du�r�ttj|�ttj|��BS|dk�r�ttj|tjd �S|dk�r�ttj|tjd �Sttj|�S||jk�r�|du�s�J�| du�r�ttj|��S| du�r�ttj|��Sttj|�S||j k�rttj|�S||jk�r"|du�sJ�|dk�rttj|tjd �Sttj|�S||jk�s*J�|du�s1J�| du�r>ttj|��S| du�rKttj|��Sttj |�S)Nz!Invalid simple spec component: %rr�r=r>r?zInvalid simple spec: %rrRr�r=r>r?r@rAr[)r�r)!r)r`r9ro�PREFIX_ALIASES�get�EMPTY_VALUESrr1� PREFIX_EQ� PREFIX_GTErd� PREFIX_NEQ�PREFIX_CARETr=rMr>rNrOr�rr�PREFIX_TILDE�PREFIX_COMPATIBLErrrr#� PREFIX_GTr� PREFIX_LT� PREFIX_LTEr ) rG�expr�prefix�major_t�minor_t�patch_t�prerelrAr=r>r?r��highrrrr*=s�� zSimpleSpec.Parser.parse_blockN)rrr�NUMBERr^r_�format�VERBOSEr)r�r:r9r:r;r6r8r<r7r=r>r3r5r*rrrrr's0�� r'N�rrrr�r�r�r'rrrrr%s r%cs0eZdZ�fdd�Zedd��Zdd�Z�ZS)� LegacySpeccsJtjdtdd�t|�dkrtjdtdd�d�|�}tt|��|�dS)NzBThe Spec() class will be removed in 3.1; use SimpleSpec() instead.r2r3rLz]Passing 2+ arguments to SimpleSpec will be removed in 3.0; concatenate them with ',' instead.r) r6r7�PendingDeprecationWarningrer8rcr�rJr!)r Zexpressionsr�r�rrr!�s�� zLegacySpec.__init__cCst|�Sr)r�rrrr�specs�szLegacySpec.specsccsV�tjdtdd�zt|j�}Wn ty|jg}Ynw|D]}t�|�Vq dS)NzLIterating over the components of a SimpleSpec object will be removed in 3.0.r2r3)r6r7r8r�r�� TypeErrorr�r�)r r�r�rrrrt�s��zLegacySpec.__iter__)rrrr!r�rLrtr�rrr�rrJ�s rJc@r$)�NpmSpecZnpmcCr�rr&r�rrrr��r�zNpmSpec._parse_to_clausec @s�eZdZdZdZdZdZe�dj eed�ej �Zedd��Z ed d ��ZdZdZd ZdZdZdZdZdeiZeejeejeejeejeejiZgd�Zedd��ZdS)zNpmSpec.Parserz||z - zx|X|\*|0|[1-9][0-9]*z[a-zA-Z0-9.-]*aQ ^(?:v)? # Strip optional initial v (?P<op><|<=|>=|>|=|\^|~|) # Operator, can be empty (?P<major>{nb})(?:\.(?P<minor>{nb})(?:\.(?P<patch>{nb}))?)? (?:-(?P<prerel>{part}))? # Optional re-release (?:\+(?P<build>{part}))? # Optional build $)r(rVcCst||tjd�S)Nr2)r�r)rGr�r�rrr�range�szNpmSpec.Parser.rangec Cs�t�}|�|j�}|D]�}|��}|sd}g}|j|vr4|�|jd�\}}|�d|�|�d|�}n |�d�}|D]} |j�| �sKtd|| f��|� |�| ��q;g} g}|D]a}|j jr�|jt jt jfvr�| �t t jt|j j|j j|j jdd�t jd ��n|jt jt jfvr�| �t t jt|j j|j jd dd�t jd ��| �|�|�|j|j|j ��d ��qZ|�|�qZ| r�|t| �O}|t|�O}q|S)Nz>=0.0.0r2r�r�� zInvalid NPM block in %r: %rrLr0)r�r�rrr)r=r>r?r@r!)r�rd�JOINER�strip�HYPHEN�parse_simple�NPM_SPEC_BLOCKr`r9�extendr�r@r�r�rr�appendrr1r=r>r?r#r rOrQr�) rGr��resultro�groupr��lowrEr+r,Zprerelease_clausesZnon_prerel_clausesr�rrrr:�sd � � �� zNpmSpec.Parser.parser�r�r�r�r�r�r�r[r-cCs�|j�|�}|��\}}}}}}|j�||�}||jvrdnt|�} ||jvr)dnt|�} ||jvr4dnt|�}|durD||jfvrDd}| duratdddd�}||j|j fvr]t d|��|j }n/| durmt| ddd�}n#|duryt| | dd�}nt| | ||r�|�d�nd|r�|�d�ndd�}| dus�| dus�|dur�|s�|r�t d|��||jkr�|j r�|��} n&|jr�|��} n| dur�|��} n|dur�|��} n|��} |�tj|�|�tj| �gS||jk�r| dus�J�| dur�|��} n|��} |�tj|�|�tj| �gS||jk�rU| du�r#|�tj|�gS| du�r8|�tj|�|�tj|��gS|du�rM|�tj|�|�tj|��gS|�tj|�gS||jk�r�| du�sbJ�| du�rq|�tj|��gS|du�r�|�tj|��gS|�tj|�gS||j k�r�|�tj|�gS||jk�r�| du�s�J�|�tj|�gS||jk�s�J�| du�s�J�| du�r�|�tj|��gS|du�r�|�tj|��gS|�tj|�gS)Nrr0zInvalid expression %rrRrr1zInvalid NPM spec: %r)rUr`ror3r4r5rr6r1r7r9rdr9r=rQrMr>rNrOrOr�rrr:rr<rr=r>r )rGr�r`r@rArBrCrDrAr=r>r?r�rErrrrTNs�� zNpmSpec.Parser.parse_simpleN) rrrrQrSrFZPARTr^r_rGrHrUr�rOr:r9r:r6r<r7r=r>r3r�rrr rrZPREFIX_TO_OPERATORr5rTrrrrr'�s@�� ;��r'NrIrrrrrN�s rN)� functoolsr^r6r�objectr �total_orderingrr)r1r�r�r`r�r�r�r�r�r�r�r�r�r�r�r%rJr�rNrrrr�<module>sB /X S#?Ao.#