� L�g&�� ���dZddlZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZe eefZe de���ZeeegefZd ed efd �ZGd �d e��ZGd�dej���ZGd�de��Zejd��Zd ed eefd�Zded efd�Z deedeed e eeeeffd�Z!Gd�de��Z"dS)z� .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version �N) �Callable�Iterable�Iterator�List�Optional�Set�Tuple�TypeVar�Union�)�canonicalize_version)�Version�UnparsedVersionVar)�bound�version�returnc�N�t|t��st|��}|S�N)� isinstancer)rs �d/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/packaging/specifiers.py�_coerce_versionr"s&�� �g�w� '� '�#��'�"�"�� �N�c��eZdZdZdS)�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__�rrrr(s���������rrc ��eZdZejdefd���Zejdefd���Zejde de fd���Z e ejde e fd�����Zejde ddfd ���Zejdd ed e e de fd ���Zej dd eed e e deefd���ZdS)� BaseSpecifierrc��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__5����rc��dS)zF Returns a hash value for this Specifier-like object. Nrr#s r�__hash__zBaseSpecifier.__hash__<r&r�otherc��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__Br&rc��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. Nrr#s r� prereleaseszBaseSpecifier.prereleasesKr&r�valueNc��dS)zQSetter for :attr:`prereleases`. :param value: The value to set. Nr�r$r/s rr.zBaseSpecifier.prereleasesTr&r�itemr.c��dS)zR Determines if the given item is contained within this specifier. Nr)r$r2r.s r�containszBaseSpecifier.contains[r&r�iterablec��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$r5r.s r�filterzBaseSpecifier.filterar&rr)rrr�abc�abstractmethod�strr%�intr(�object�boolr,�propertyrr.�setterr4rrrr7rrrr!r!4s��������� �� � � ��� �  �� �#� � � ��� �  �� �F� �t� � � ��� ���� �X�d�^� � � ����X� ��� �� �$� � � ��� �  �� � �S� �x��~� �� � � ��� �  ��TX� � � �!3�4� �CK�D�>� � �$� %� � � ��� � � rr!)� metaclassc ��eZdZdZdZdZejdezezdzejej z��Z dddd d d d d d�Z d1de de eddfd�Zedefd���Zejdeddfd���Zede fd���Zede fd���Zde fd�Zde fd�Zedee e ffd���Zdefd�Zdedefd�Zd e defd!�Zd"ede defd#�Z d"ede defd$�Z!d"ede defd%�Z"d"ede defd&�Z#d"ede defd'�Z$d"ed(e defd)�Z%d"ed(e defd*�Z&d"ede defd+�Z'd,e(e efdefd-�Z) d2d,e*de edefd.�Z+ d2d/e,e-de ede.e-fd0�Z/dS)3� 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.rc��|j�|��}|std|�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: '�'�operatorrN)�_regex�searchr�group�strip�_spec� _prereleases)r$rSr.�matchs r�__init__zSpecifier.__init__�s���� �"�"�4�(�(��� C�"�#A�$�#A�#A�#A�B�B� B� �K�K� � #� #� )� )� +� +� �K�K� � "� "� (� (� *� *�' �� � (����rc��|j�|jS|j\}}|dvr;|dkr|�d��r |dd�}t|��jrdSdS)N)rLrNrMrKrQrL�.*�����TF)r\r[�endswithr� is_prerelease)r$rVrs rr.zSpecifier.prereleasess|�� � � (��$� $� !�J���'� �6� 6� 6��4���G�$4�$4�T�$:�$:��!�#�2�#�,���w���-� ��t��urr/c��||_dSr�r\r1s rr.zSpecifier.prereleases���!����rc��|jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' r�r[r#s rrVzSpecifier.operator����z�!�}�rc��|jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rhr#s rrzSpecifier.version%rirc�l�|j� d|j��nd}d|jj�dt |���|�d�S)aTA 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=rRrO�(�)>)r\r.� __class__rr:�r$�pres r�__repr__zSpecifier.__repr__.sT��� �,� 2�T�-� 1� 1� 1�� � B�4�>�*�A�A�S��Y�Y�A�#�A�A�A�Arc� �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{}{})�formatr[r#s rr%zSpecifier.__str__@s���v�}�d�j�)�)rc�v�t|jd|jddk���}|jd|fS)Nr rrK��strip_trailing_zero)r r[)r$�canonical_versions r�_canonical_speczSpecifier._canonical_specJsB��0� �J�q�M�!%��A��$�!6� � � ���z�!�}�/�/�/rc�*�t|j��Sr)�hashryr#s rr(zSpecifier.__hash__Rs���D�(�)�)�)rr)c���t|t��r; |�t|����}n3#t$r tcYSwxYwt||j��stS|j|jkS)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 )rr:ror�NotImplementedryr+s rr,zSpecifier.__eq__Us���& �e�S� !� !� "� &����s�5�z�z�2�2����#� &� &� &�%�%�%�%� &�����E�4�>�2�2� "�!� !��#�u�'<�<�<s�":�A� A�opc�B�t|d|j|����}|S)N� _compare_)�getattr� _operators)r$r~�operator_callables r� _get_operatorzSpecifier._get_operatorrs/��.5� �3�d�o�b�1�3�3�/ �/ ��!� r� prospectivec �&�d�ttjtt |������dd���}|dz }|�d��||��o|�d��||��S)N�.�����r`rNrL)�join�list� itertools� takewhile�_is_not_suffix�_version_splitr�)r$r�rS�prefixs r�_compare_compatiblezSpecifier._compare_compatiblexs������ ��$�^�^�D�5I�5I�J�J� K� K�C�R�C� P� � �� �$���'�t�!�!�$�'�'� �T�:�:� �?W�t�?Q�?Q�RV�?W�?W� ��@ �@ � rc��|�d��r}t|jd���}t|dd�d���}t|��}t|��}t ||��\}}|dt |���} | |kSt |��} | jst |j��}|| kS)Nr`Frvra)rbr �publicr�� _pad_version�lenr�local) r$r�rS�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� ��,�.� .rc�0�|�||�� Sr)r��r$r�rSs r�_compare_not_equalzSpecifier._compare_not_equal�s���&�&�{�D�9�9�9�9rc�L�t|j��t|��kSr�rr�r�s r�_compare_less_than_equalz"Specifier._compare_less_than_equal�� �� �{�)�*�*�g�d�m�m�;�;rc�L�t|j��t|��kSrr�r�s r�_compare_greater_than_equalz%Specifier._compare_greater_than_equal�r�r�spec_strc��t|��}||ksdS|js3|jr,t|j��t|j��krdSdS�NFT)rrc� base_version�r$r�r�rSs r�_compare_less_thanzSpecifier._compare_less_than�sg���x� � �� �T�!�!��5� �!� �k�&?� ��{�/�0�0�G�D�<M�4N�4N�N�N��u� �trc��t|��}||ksdS|js3|jr,t|j��t|j��krdS|j�,t|j��t|j��krdSdSr�)r�is_postreleaser�r�r�s r�_compare_greater_thanzSpecifier._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� �trc��t|�����t|�����kSr)r:�lowerr�s r�_compare_arbitraryzSpecifier._compare_arbitrary�s1���;���%�%�'�'�3�t�9�9�?�?�+<�+<�<�<rr2c�,�|�|��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 �r4�r$r2s r� __contains__zSpecifier.__contains__���&�}�}�T�"�"�"rc��|�|j}t|��}|jr|sdS|�|j��}|||j��S)alReturn 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)r.rrcr�rVr)r$r2r.�normalized_itemr�s rr4zSpecifier.containssg��8 � ��*�K�*�$�/�/�� � (� �� ��5�/3�.@�.@���.O�.O�� � ��$�,�?�?�?rr5c#��K�d}g}d|�|ndi}|D]K}t|��}|j|fi|��r,|jr|s|js|�|���Ed}|V��L|s |r |D] }|V��dSdSdS)aOFilter 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'] Fr.NT)rr4rcr.�append)r$r5r.�yielded�found_prereleases�kwr�parsed_versions rr7zSpecifier.filterEs�����<�����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�rRNr)0rrrr�_operator_regex_str�_version_regex_str�re�compile�VERBOSE� IGNORECASErWr�r:rr=r^r>r.r?rVrrrr%r ryr;r(r<r,�CallableOperatorr�rr�r�r�r�r�r�r�r�r r��UnparsedVersionr4rrrr7rrrrBrBks/�������� ��\ ��|�R�Z��%�%�(:�:�W�D� � �R�]�"���F� ����"� � �� � �J�(�(�S�(�H�T�N�(�d�(�(�(�(�4��T�����X��.��"��"�$�"�"�"���"���#�����X���������X��B�#�B�B�B�B�$*��*�*�*�*��0��s�C�x��0�0�0��X�0�*�#�*�*�*�*�=�F�=�t�=�=�=�=�:!��!�(8�!�!�!�!�  �w� �c� �d� � � � �*'/�'�'/��'/��'/�'/�'/�'/�R:�g�:�S�:�T�:�:�:�:�<�G�<�3�<�4�<�<�<�<�<�w�<�c�<�d�<�<�<�<��g���������2���C��D�����>=�g�=�S�=�T�=�=�=�=�#��s�G�|�!4�#��#�#�#�#�,DH�,@�,@�#�,@�2:�4�.�,@� �,@�,@�,@�,@�^UY�;�;� �!3�4�;�CK�D�>�;� �$� %�;�;�;�;�;�;rrBz^([0-9]+)((?:a|b|c|rc)[0-9]+)$c���g}|�d��D][}t�|��}|r(|�|������F|�|���\|S)Nr�)�split� _prefix_regexrX�extend�groupsr�)r�resultr2r]s rr�r��st���F�� � �c�"�"� � ���$�$�T�*�*�� � � �M�M�%�,�,�.�.� )� )� )� )� �M�M�$� � � � � �Mr�segmentc�<��t�fd�dD���� S)Nc3�B�K�|]}��|��V��dSr)� startswith)�.0r�r�s �r� <genexpr>z!_is_not_suffix.<locals>.<genexpr>�sB�������'-����6�"�"������r)�dev�a�b�rc�post)�any)r�s`rr�r��s@��������1P������ �r�left�rightc �R�gg}}|�ttjd�|������|�ttjd�|������|�|t |d��d���|�|t |d��d���|�ddgt dt |d��t |d��z ��z��|�ddgt dt |d��t |d��z ��z��ttj|���ttj|���fS)Nc�*�|���Sr��isdigit��xs r�<lambda>z_pad_version.<locals>.<lambda>�s�������rc�*�|���Srr�r�s rr�z_pad_version.<locals>.<lambda>�s��!�)�)�+�+�rrr �0)r�r�r�r�r��insert�max�chain)r�r�� left_split� right_splits rr�r��sr�� �"� �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�_�k�5R�0S�0S� T�Trc ��eZdZdZ ddedeeddfd�Zedeefd���Z e j d eddfd ���Z defd �Z defd �Z de fd �Zdedefddfd�Zdedefd�Zde fd�Zdeefd�Zdedefd�Z ddedeedeedefd�Z ddeedeedeefd�ZdS)� 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. rRN� specifiersr.rc���d�|�d��D��}t��}|D]$}|�t|�����%t |��|_||_dS)aNInitialize 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|]*}|����|�����+Sr)rZ�r��ss r� <listcomp>z)SpecifierSet.__init__.<locals>.<listcomp>�s-��R�R�R�!���� � �R�A�G�G�I�I�R�R�Rr�,N)r��set�addrB� frozenset�_specsr\)r$r�r.�split_specifiers�parsed� specifiers rr^zSpecifierSet.__init__�s��(S�R�z�/?�/?��/D�/D�R�R�R��"%����)� -� -�I� �J�J�y��+�+� ,� ,� ,� ,� ��'�'�� �(����rc�l�|j�|jS|jsdStd�|jD����S)Nc3�$K�|] }|jV�� dSr�r.r�s rr�z+SpecifierSet.prereleases.<locals>.<genexpr>�s$����6�6�Q�1�=�6�6�6�6�6�6r)r\r�r�r#s rr.zSpecifierSet.prereleases�sH�� � � (��$� $� �{� ��4��6�6�$�+�6�6�6�6�6�6rr/c��||_dSrrer1s rr.zSpecifierSet.prereleases�rfrc�R�|j� d|j��nd}dt|���|�d�S)aA 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)> NrlrRz<SpecifierSet(rn)r\r.r:rps rrrzSpecifierSet.__repr__�sF��� �,� 2�T�-� 1� 1� 1�� � 5��D� � �4�S�4�4�4�4rc�d�d�td�|jD������S)anA 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�c3�4K�|]}t|��V��dSr)r:r�s rr�z'SpecifierSet.__str__.<locals>.<genexpr>s(����;�;�!�s�1�v�v�;�;�;�;�;�;r)r��sortedr�r#s rr%zSpecifierSet.__str__�s/���x�x��;�;�t�{�;�;�;�;�;�<�<�<rc�*�t|j��Sr)r{r�r#s rr(zSpecifierSet.__hash__ s���D�K� � � rr)c��t|t��rt|��}nt|t��stSt��}t |j|jz��|_|j�|j� |j|_nG|j�|j� |j|_n,|j|jkr |j|_ntd���|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.)rr:r�r}r�r�r\� ValueError)r$r)r�s 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� "� "����� � �rc���t|ttf��rtt|����}nt|t��stS|j|jkS)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 )rr:rBr�r}r�r+s rr,zSpecifierSet.__eq__-sW��& �e�c�9�-� .� .� "� ��U���,�,�E�E��E�<�0�0� "�!� !��{�e�l�*�*rc�*�t|j��S)z7Returns the number of specifiers in this specifier set.)r�r�r#s r�__len__zSpecifierSet.__len__Gs���4�;���rc�*�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__Ks���D�K� � � rr2c�,�|�|��S)arReturn 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 rr�zSpecifierSet.__contains__Ur�r� installedc�����t�t��st������|j��s �jrdS|r�jrt�j���t ��fd�|jD����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 NFc3�F�K�|]}|������V��dS)r�Nr�)r�r�r2r.s ��rr�z(SpecifierSet.contains.<locals>.<genexpr>�s3�����R�R��1�:�:�d� �:�<�<�R�R�R�R�R�Rr)rrr.rcr��allr�)r$r2r.rs `` rr4zSpecifierSet.containsjs�����<�$��(�(� !��4�=�=�D� � ��*�K�� �t�1� ��5� � .��+� .��4�,�-�-�D� �R�R�R�R�R�d�k�R�R�R�R�R�Rrr5c��|�|j}|jr=|jD]&}|�|t|�����}�'t |��Sg}g}|D]G}t |��}|jr|s|s|�|���2|�|���H|s|r|�t |��St |��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�)r.r�r7r=r rrcr�)r$r5r.rS�filteredr�r2r�s rr7zSpecifierSet.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��-�.�.�.���>�>� !rr�)NNr)rrrrr:rr=r^r>r.r?rrr%r;r(r rr<r,r rrBr r�r�r4rrr7rrrr�r��s`��������CG�!(�!(��!(�19�$��!(� �!(�!(�!(�!(�F�7�X�d�^�7�7�7��X�7� ��"��"�$�"�"�"���"�5�#�5�5�5�5�* =�� =� =� =� =�!�#�!�!�!�!��U�>�3�#6�7��N�����@+�F�+�t�+�+�+�+�4 �� � � � �!�(�9�-�!�!�!�!�#��#�T�#�#�#�#�0'+�$(� 7S�7S��7S��d�^�7S��D�>� 7S� � 7S�7S�7S�7S�tUY�M"�M"� �!3�4�M"�CK�D�>�M"� �$� %�M"�M"�M"�M"�M"�M"rr�)#rr8r�r��typingrrrrrrr r r �utilsr rrr:r�rr=r�rrr�ABCMetar!rBr�r�r�r�r�r�rrr�<module>rs����� � � � ����� � � � � � � � � � � � � � � � � � � � � � � � � � �(�'�'�'�'�'���������� �%���W�1��I�I�I���W�c�N�D�0�1���_������� � � � � �z� � � �4 �4 �4 �4 �4 �c�k�4 �4 �4 �4 �nU�U�U�U�U� �U�U�U�p�� �<�=�=� ��C��D��I������C��D����� U�t�C�y�U��c��U�u�T�#�Y��S� �=Q�7R�U�U�U�U�$G"�G"�G"�G"�G"�=�G"�G"�G"�G"�G"r
Memory