Uname:Linux developmentwebsite.ca 4.18.0-553.168.1.el8_10.x86_64 #1 SMP Thu Sep 24 18:05:46 UTC 2026 x86_64

403WebShell
403Webshell
Server IP : 173.249.148.11  /  Your IP : 216.73.216.179
Web Server : Apache/2.4.68 (AlmaLinux)
System : Linux developmentwebsite.ca 4.18.0-553.168.1.el8_10.x86_64 #1 SMP Thu Sep 24 18:05:46 UTC 2026 x86_64
User : devinter ( 1006)
PHP Version : 8.3.35
Disable Function : NONE
MySQL : ON  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : ON  |  Pkexec : ON
Directory :  /snap/certbot/current/lib/python3.12/site-packages/packaging/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /snap/certbot/current/lib/python3.12/site-packages/packaging/__pycache__/specifiers.cpython-312.pyc
�

��j>���^�UdZddlmZddlZddlZddlZddlmZmZmZm	Z	m
Z
mZddlm
Z
mZmZmZmZmZmZmZmZddlmZddlmZer6ddlZdd	lmZmZmZej>d
k\rddlm Z nddl!m Z ddl"m#Z#dd
lm$Z$gd�Z%d$d�Z&d%d�Z'd&d�Z(e
d�Z)eee*fZ+e
de+��Z,ejZej\ej^ej`d�Z1de2d<d'd�Z3Gd�de4�Z5Gd�dejl��Z7Gd�de7�Z8								d(d �Z9Gd!�d"e7�Z:						d)d#�Z;y)*z�
.. testsetup::

    from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
    from packaging.version import Version
�)�annotationsN)�
TYPE_CHECKING�Any�Callable�Final�TypeVar�Union�)	�
FULL_RANGE�bounds_for_spec�coerce_version�filter_by_ranges�intersect_specifier_bounds�matches_bounds_only�ranges_are_prerelease_only�resolve_prereleases�trim_release)�canonicalize_version)�Version)�Iterable�Iterator�Sequence)��
)�	TypeGuard)�ranges)�Interval)�
BaseSpecifier�InvalidSpecifier�	Specifier�SpecifierSetc��tS�N)�__all__���P/root/parts/certbot/install/lib/python3.12/site-packages/packaging/specifiers.py�__dir__r(<s���Nr&c��t|t�xr8t|�dk(xr(t|dt�xrt|dt�S)N�rr
)�
isinstance�tuple�len�str)�specs r'�_validate_specr0@sI���4���	%���I��N�	%��t�A�w��$�	%�
�t�A�w��$�	r&c�.�|duxst|t�Sr#)r+�bool)�pres r'�
_validate_prer4Is���$�;�/�*�S�$�/�/r&�T�UnparsedVersionVar)�bound)�>=�<=�==�!=z-dict[str, Callable[[Version, Version], bool]]�_DIRECT_COMPARE_OPSr c��|j\}}|jd�s|j�ytj	|�}|�|||j|��S|dvre|j|�}|j|jk7s+t|j�t|j�k7r|dk(r||kS||kDSyy)a!Match ``parsed`` against ``specifier`` without building a range.

    Handles ``>=``, ``<=``, ``==``, ``!=``, ``<``, ``>`` when the spec is
    not a wildcard and ``parsed`` has no local. Returns ``None`` when the
    range path must be used. Pre-release policy is left to the caller.
    �.*N)�<�>r?)	�_spec�endswith�localr<�get�_require_spec_version�epochr�release)�	specifier�parsed�op_str�ver_str�direct_compare�spec_vs      r'�_fast_matchrN]s��� �o�o�O�F�G���������!9��(�,�,�V�4�N��!��f�i�&E�&E�g�&N�O�O�
����0�0��9���<�<�6�<�<�'�<����+G�<��N�N�L
�,
�'-��m�6�F�?�H��&��H��r&c��eZdZdZy)ra
    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'rrzs��r&rc���eZdZdZdZdZedd��Zejdd��Z
ejdd��Zejdd��Zeejdd���Z
e
jdd	��Z
ejddd��Zej"		d							dd��Zej"		d							dd
��Zej		d							dd��Zy
)rzO
    Abstract base class for :class:`Specifier` and :class:`SpecifierSet`.
    r%)�_strc��t|�S)z Internal property for match_args�r.��selfs r'rUzBaseSpecifier._str�s���4�y�r&c��y)z�
        Returns the str representation of this Specifier-like object. This
        should be representative of the Specifier itself.
        Nr%rXs r'�__str__zBaseSpecifier.__str__���r&c��y)zF
        Returns a hash value for this Specifier-like object.
        Nr%rXs r'�__hash__zBaseSpecifier.__hash__�r\r&c��y)z�
        Returns a boolean representing whether or not the two Specifier-like
        objects are equal.

        :param other: The other object to check against.
        Nr%�rY�others  r'�__eq__zBaseSpecifier.__eq__�r\r&c��y)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%rXs r'�prereleaseszBaseSpecifier.prereleases�r\r&c��y)zQSetter for :attr:`prereleases`.

        :param value: The value to set.
        Nr%�rY�values  r'rdzBaseSpecifier.prereleases�r\r&Nc��y)zR
        Determines if the given item is contained within this specifier.
        Nr%)rY�itemrds   r'�containszBaseSpecifier.contains�r\r&c��yr#r%�rY�iterablerd�keys    r'�filterzBaseSpecifier.filter����(+r&c��yr#r%rls    r'rozBaseSpecifier.filter����r&c��y)z�
        Takes an iterable of items and filters them so that only items which
        are contained within this specifier are allowed in it.
        Nr%rls    r'rozBaseSpecifier.filter�r\r&��returnr.�ru�int�ra�objectrur2�ru�bool | None)rgr2ru�Noner#)rir.rdr{rur2�N.�rmzIterable[UnparsedVersionVar]rdr{rnr|ruzIterator[UnparsedVersionVar]�rmzIterable[T]rdr{rnzCallable[[T], UnparsedVersion]ruzIterator[T]�NN�rm�
Iterable[Any]rdr{rn�'Callable[[Any], UnparsedVersion] | Noneru�
Iterator[Any])rPrQrRrS�	__slots__�__match_args__�propertyrU�abc�abstractmethodr[r^rbrd�setterrj�typing�overloadror%r&r'rr�s�����I��N�
����	������	������
	��������������������	������
�_�_�$(��	+�.�+�!�+��	+�

&�+��+��_�_�$(�.1�	���!��,�	�

����	���$(�7;�		��	�!�	�5�		�

�	��	r&r)�	metaclassc	��eZdZUdZdZdZejdezdzejejz�Z
ddddd	d
ddd
�Zded<d%d&d�Z
d'd�Zd(d�Zd)d�Zed*d��Zej&d+d��Zd,d�Zd-d�Zed.d��Zed.d��Zd.d�Zd.d�Zed/d��Zd0d�Zd1d�Zd2d �Zd3d4d!�Zej@		d5							d6d"��Z!ej@		d5							d7d#��Z!		d8							d9d$�Z!y):r a�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).

    Instances are safe to serialize with :mod:`pickle`. They use a stable
    format so the same pickle can be loaded in future packaging releases.

    .. versionchanged:: 26.2

        Added a stable pickle format. Pickles created with packaging 26.2+ can
        be unpickled with future releases.  Backward compatibility with pickles
        from packaging < 26.2 is supported but may be removed in a future
        release.
    )�_prereleases�_rangesrA�
_spec_versiona
        (?:
            (?:
                # 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 .*
                    |
                    (?a:                                  # pre release
                        [-_\.]?
                        (alpha|beta|preview|pre|a|b|c|rc)
                        [-_\.]?
                        [0-9]*
                    )?
                    (?a:                                  # post release
                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                    )?
                    (?a:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
                    (?a:\+[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.
                (?:<=|>=|<|>)

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)*   # release
                (?a:                   # pre release
                    [-_\.]?
                    (alpha|beta|preview|pre|a|b|c|rc)
                    [-_\.]?
                    [0-9]*
                )?
                (?a:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?a:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
        )
        z\s*�
compatible�equal�	not_equal�less_than_equal�greater_than_equal�	less_than�greater_than�	arbitrary)�~=r:r;r9r8r?r@�===r�
_operatorsNc��|jj|�std|����|j�}|j	d�r|dd|ddj�}}nB|j	d�r|dd|ddj�}}n|dd|ddj�}}||f|_||_d|_d|_y)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: r�Nr)r�r:r;r9r8r*r
)	�_regex�	fullmatchr�strip�
startswithrAr�r�r�)rYr/rd�operator�versions     r'�__init__zSpecifier.__init__cs����{�{�$�$�T�*�"�%8���#A�B�B��z�z�|���?�?�5�!� $�R�a��$�q�r�(�.�.�*:�g�H�
�_�_�;�
<� $�R�a��$�q�r�(�.�.�*:�g�H� $�R�a��$�q�r�(�.�.�*:�g�H�'/��&9��
�(���:>���37��r&c��|j�!|jd|k(r|jdSt|�}|�y||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr
)r�r
)rYr��version_specifiers   r'�_get_spec_versionzSpecifier._get_spec_version�sY�����)�d�.@�.@��.C�w�.N��%�%�a�(�(�*�7�3���$��%�'8�9��� � r&c�0�|j|�}|�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 ===).
        )r�)rYr��spec_versions   r'rEzSpecifier._require_spec_version�s&���-�-�g�6���'�'�'��r&c���|j�|jS|j}|j}|dk(rt}n-|j	|jd��}t
|||�}||_|S)z�Convert this specifier to sorted, non-overlapping version ranges.

        Each standard operator maps to one or two ranges.  ``===`` is
        modeled as full range (actual check done separately).  Cached.
        r�r>)r�r�r�rrE�removesuffixr)rY�oprK�resultr�s     r'�
_to_rangeszSpecifier._to_ranges�sk���<�<�#��<�<��
�]�]���,�,��
��;�)3�F��0�0��1E�1E�d�1K�L�G�$�R��'�:�F�����
r&c���|j�|jS|j\}}|dk(ry|dk(r|jd�ry|j|�}|�y|jS)Nr;Fr:r>)r�rArBr��
is_prerelease)rYr��version_strr�s    r'rdzSpecifier.prereleases�sy�����(��$�$�$�!%�
�
���+��t����t��� 4� 4�T� :���(�(��5���?���$�$�$r&c��||_yr#)r�rfs  r'rdzSpecifier.prereleases�s
��!��r&c�2�|j|jfSr#)rAr�rXs r'�__getstate__zSpecifier.__getstate__�s���
�
�D�-�-�.�.r&c�V�d|_d|_t|t�r�t	|�dk(r*|\}}t|�rt
|�r||_||_yt	|�dk(r`t|dt�rM|\}}|jd�}|jdd�}t|�rt
|�r||_||_yt|t�rH|jd�}|jdd�}t|�rt
|�r||_||_ytd|����)Nr*r
rAr��invalidzCannot restore Specifier from )r�r�r+r,r-r0r4rAr��dictrD�	TypeError)rY�stater/rd�_�	slot_dicts      r'�__setstate__zSpecifier.__setstate__�s
��!�������e�U�#��5�z�Q��$)�!��k�!�$�'�M�+�,F�!%�D�J�(3�D�%���5�z�Q��:�e�A�h��#=�$���9� �}�}�W�-��'�m�m�N�I�F��!�$�'�M�+�,F�!%�D�J�(3�D�%���e�T�"��9�9�W�%�D��)�)�N�I�>�K��d�#�
�k�(B�!��
�$/��!���8��	�B�C�Cr&c� �|jdS)z`The operator of this specifier.

        >>> Specifier("==1.2.3").operator
        '=='
        r�rArXs r'r�zSpecifier.operator�����z�z�!�}�r&c� �|jdS)zaThe version of this specifier.

        >>> Specifier("==1.2.3").version
        '1.2.3'
        r
r�rXs r'r�zSpecifier.versionr�r&c��|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)>
        �, prereleases=�r?�(�)>�r�rd�	__class__rPr.�rYr3s  r'�__repr__zSpecifier.__repr__
sU��� � �,��T�-�-�0�1��	��4�>�>�*�*�+�1�S��Y�M�#��b�A�Ar&c�4�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{}{})�formatrArXs r'r[zSpecifier.__str__s���v�}�}�d�j�j�)�)r&c��|j\}}|dk(s|jd�r||fS|j|�}t||dk7��}||fS)Nr�r>r�)�strip_trailing_zero)rArBrEr)rYr�r�r��canonical_versions     r'�_canonical_speczSpecifier._canonical_spec&sc�� �J�J���'��u��� 0� 0�� 6��W�$�$��1�1�'�:��0��x�4�/?�
���*�*�*r&c�,�t|j�Sr#)�hashr�rXs r'r^zSpecifier.__hash__4s���D�(�(�)�)r&c���t|t�r	|jt|��}nt||j�stS|j
|j
k(S#t$r	tcYSwxYw)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.r�r�NotImplementedr�r`s  r'rbzSpecifier.__eq__7si��&�e�S�!�
&����s�5�z�2���E�4�>�>�2�!�!��#�#�u�'<�'<�<�<��$�
&�%�%�
&�s�A"�"A4�3A4c�$�|j|�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
        �rj�rYris  r'�__contains__zSpecifier.__contains__T���&�}�}�T�"�"r&c�H�|jddk(r&tt|j|g|����St	|�}|�y|� t|j|j�}|dur
|jryt||�}|�|St|j�|�S)a'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:`~packaging.version.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

        .. versionchanged:: 26.0

            With ``prereleases=None``, a prerelease now matches. A single
            version has no alternatives, so the :pep:`440` rule to accept
            prereleases when nothing else satisfies the specifier applies.
            Earlier versions rejected it. An unparsable version now returns
            ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`.
        rr��rdF)rAr2�listror
rr�rdr�rNrr�)rYrirdrI�matchs     r'rjzSpecifier.containsis���D�:�:�a�=�E�!���T�[�[�$��[�[�I�J�K�K���%���>����-�d�.?�.?��AQ�AQ�R�K��%��F�$8�$8���D�&�)�����L�"�4�?�?�#4�f�=�=r&c��yr#r%rls    r'rozSpecifier.filter�rpr&c��yr#r%rls    r'rozSpecifier.filter�rrr&c����|� t|j|j�}|jdk(r3|jj����fd�|D�}t
|�|�St|j�|�|�S)a�Filter items in the given iterable, that match the specifier.

        :param iterable:
            An iterable that can contain version strings and
            :class:`~packaging.version.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.
        :param key:
            A callable that takes a single argument (an item from the iterable) and
            returns a version string or :class:`~packaging.version.Version`
            instance to be used for filtering.

        >>> 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']
        >>> list(Specifier(">=1.2.3").filter(
        ... [{"ver": "1.2"}, {"ver": "1.3"}],
        ... key=lambda x: x["ver"]))
        [{'ver': '1.3'}]

        .. versionchanged:: 26.1

            Added the ``key`` parameter.
        r�c3�n�K�|],}t��|n�|��j��k(r|���.y�wr#)r.�lower)�.0rirn�
spec_lowers  ��r'�	<genexpr>z#Specifier.filter.<locals>.<genexpr>�s9��������s�{�t��D�	�:�@�@�B�j�P���s�25)	rr�rdr�r�r��_apply_prereleases_filterrr�)rYrmrdrn�matchesr�s   ` @r'rozSpecifier.filter�sz���P��-�d�.?�.?��AQ�AQ�R�K��=�=�E�!����+�+�-�J��$��G�
-�W�c�;�G�G����� 1�8�S�+�N�Nr&�r�N)r/r.rdr{rur|)r�r.ruzVersion | None)r�r.rur�ruzSequence[Interval]rz�rgr{rur|)ruz#tuple[tuple[str, str], bool | None]�r�ryrur|rt)ruztuple[str, str]rvrx)riz
str | Versionrur2r#)ri�UnparsedVersionrdr{rur2r}r~rr�r�)"rPrQrRrSr��_specifier_regex_str�re�compile�VERBOSE�
IGNORECASEr�r��__annotations__r�r�rEr�r�rdr�r�r�r�r�r�r[r�r^rbr�rjr�r�ror%r&r'r r �s����&�I�Z��x�R�Z�Z��%�%��.��
�
�R�]�]�0J��F�����"�
�
��	�J��	�!7�F
!���*�%��%�6���"��"�/�D�B��������B�$*��+��+�*�=�:#�*6>�p�_�_�$(��	+�.�+�!�+��	+�

&�+��+��_�_�$(�.1�	���!��,�	�

����$(�7;�	4O��4O�!�4O�5�	4O�

�4Or&c�T���|�t|��S|rt|�S��fd�|D�S)z�Apply ``prereleases=`` handling to an already-matched iterable.

    ``None`` means PEP 440 default (buffer pre-releases until a final
    appears); ``True`` yields everything; ``False`` drops pre-releases.
    c3�h�K�|])}t��|n�|��x���js|���+y�wr#)r
r�)r�rirnrIs  ��r'r�z,_apply_prereleases_filter.<locals>.<genexpr>�s<�������$�S�[�T�c�$�i�H�H�F�Q��#�#�	
��s�/2)�_pep440_filter_prereleases�iter)r�rnrdrIs ` @r'r�r��s7�����)�'�3�7�7���G�}�����r&c��eZdZdZdZ		d					dd�Zd d�Zed!d��Zejd"d��Zd#d�Z
d$d	�Zd%d
�Zd%d�Z
d&d�Zd'd
�Zd(d�Zd&d�Zd)d�Zd*d�Zd+d�Zd+d�Zd,d�Zd-d�Zd.d�Zd.d�Zd.d�Zd/d�Z		d0							d1d�Zej<		d2							d3d��Zej<		d2							d4d��Z		d0							d5d�Zy)6r!a�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.

    Instances are safe to serialize with :mod:`pickle`. They use a stable
    format so the same pickle can be loaded in future packaging
    releases.

    .. versionchanged:: 26.2

        Added a stable pickle format. Pickles created with
        packaging 26.2+ can be unpickled with future releases.
        Backward compatibility with pickles from
        packaging < 26.2 is supported but may be removed in a future
        release.
    )�_canonicalized�_has_arbitrary�_is_unsatisfiabler�r��_specsNc��t|t�re|jd�D�cgc]#}|j�s�|j���%}}t	tt|��|_d|v|_n1t	|�|_td�|jD��|_t|j�dk|_d|_d|_
||_ycc}w)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.
        �,r�c3�6K�|]}dt|�v���y�w�r�NrW�r��ss  r'r�z(SpecifierSet.__init__.<locals>.<genexpr><s����%K�!�e�s�1�v�o�%K���r
N)r+r.�splitr�r,�mapr r�r��anyr-r�r�r�r�)rY�
specifiersrdr�split_specifierss     r'r�zSpecifierSet.__init__s���,�j�#�&�4>�3C�3C�C�3H�V�a�A�G�G�I����	�V��V�16�s�9�FV�7W�1X�D�K�"'�:�"5�D���
�+�D�K�#&�%K�t�{�{�%K�"K�D��!�$�+�+�.�!�3���.2���26���(����# Ws
�C�Cc��|jsCttjt	|j
t����|_d|_|j
S)zBDeduplicate, sort, and cache specs for order-sensitive operations.�rnT)r�r,r��fromkeys�sortedr�r.rXs r'�_canonical_specszSpecifierSet._canonical_specsFs=���"�"���
�
�f�T�[�[�c�.J� K�L�D�K�"&�D���{�{�r&c��|j�|jS|jsytd�|jD��ryy)Nc3�4K�|]}|j���y�wr#r�r�s  r'r�z+SpecifierSet.prereleases.<locals>.<genexpr>\s����2��q�}�}�2�s�T)r�r�rrXs r'rdzSpecifierSet.prereleasesMsB�����(��$�$�$�
�{�{���2�d�k�k�2�2��r&c� �||_d|_yr#)r�r�rfs  r'rdzSpecifierSet.prereleasesas��!���!%��r&c�2�|j|jfSr#)r�r�rXs r'r�zSpecifierSet.__getstate__fs�����T�.�.�/�/r&c���d|_d|_t|t��rft	|�dk(rk|\}}t|t�rVtd�|D��rDt
|�r9||_||_t	|�dk|_	td�|D��|_yt	|�dk(r�t|dt�r�|\}}|jdd�}|jd�}t|t�rtt|t ���}t|t�rjtd	�|D��rXt
|�rM||_||_t	|j�dk|_	td
�|jD��|_yt|t�r�|jdd�}|jd�}t|t�rtt|t ���}t|t�rjtd�|D��rXt
|�rM||_||_t	|j�dk|_	td�|jD��|_yt#d
|����)Nr*c3�<K�|]}t|t����y�wr#�r+r r�s  r'r�z,SpecifierSet.__setstate__.<locals>.<genexpr>w�����D��J�q�)�4�D���r
c3�6K�|]}dt|�v���y�wr�rWr�s  r'r�z,SpecifierSet.__setstate__.<locals>.<genexpr>}s����-M�!�e�s�1�v�o�-M�rr�r%r�rc3�<K�|]}t|t����y�wr#rr�s  r'r�z,SpecifierSet.__setstate__.<locals>.<genexpr>�rrc3�6K�|]}dt|�v���y�wr�rWr�s  r'r�z,SpecifierSet.__setstate__.<locals>.<genexpr>�s����-S�!�e�s�1�v�o�-S�rc3�<K�|]}t|t����y�wr#rr�s  r'r�z,SpecifierSet.__setstate__.<locals>.<genexpr>�s����@�Q�
�1�i�0�@�rc3�6K�|]}dt|�v���y�wr�rWr�s  r'r�z,SpecifierSet.__setstate__.<locals>.<genexpr>�s����)O�a�%�3�q�6�/�)O�rz!Cannot restore SpecifierSet from )r�r�r+r,r-�allr4r�r�r�rr�r�rD�	frozensetr
r.r�)rYr��specsrdr�r�s      r'r�zSpecifierSet.__setstate__ls������!%����e�U�#��5�z�Q��%*�"��{��u�e�,��D�e�D�D�%�k�2�"'�D�K�(3�D�%�*-�e�*��/�D�'�*-�-M�u�-M�*M�D�'���5�z�Q��:�e�A�h��#=�$���9�!�
�
�h��3��'�m�m�N�;���e�Y�/�!�&��C�"8�9�E��u�e�,��D�e�D�D�%�k�2�"'�D�K�(3�D�%�*-�d�k�k�*:�a�*?�D�'�*-�-S�t�{�{�-S�*S�D�'���e�T�"��I�I�h��+�E��)�)�N�3�K��%��+��f�U��4�5���5�%�(��@�%�@�@�!�+�.�#���$/��!�&)�$�+�+�&6�!�&;��#�&)�)O�4�;�;�)O�&O��#���;�E�9�E�F�Fr&c��|j�d|j��nd}d|jj�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)>
        r�r�r?r�r�r�r�s  r'r�zSpecifierSet.__repr__�sU��� � �,��T�-�-�0�1��	��4�>�>�*�*�+�1�S��Y�M�#��b�A�Ar&c�N�djd�|j�D��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�2K�|]}t|����y�wr#rWr�s  r'r�z'SpecifierSet.__str__.<locals>.<genexpr>�s����@�1��A��@�s�)�joinrrXs r'r[zSpecifierSet.__str__�s"���x�x�@��(=�(=�(?�@�@�@r&c�4�t|j��Sr#)r�rrXs r'r^zSpecifierSet.__hash__�s���D�)�)�+�,�,r&c���t|t�rt|�}nt|t�stSt�}|j|jz|_t|j�dk|_|jxs|j|_|j�|j|jk(r|j|_|S|j�|j|_|Std��)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')>
        r
zFCannot combine SpecifierSets with True and False prerelease overrides.)
r+r.r!r�r�r-r�r�r��
ValueError)rYrarHs   r'�__and__zSpecifierSet.__and__�s����e�S�!� ��'�E��E�<�0�!�!� �N�	��;�;����5�	��#&�y�'7�'7�#8�A�#=�	� �#'�#6�#6�#N�%�:N�:N�	� ����$��(9�(9�U�=O�=O�(O�%*�%7�%7�I�"����
�
�
'�%)�%6�%6�I�"���	�X��
r&c���t|ttf�rtt|��}nt|t�stS|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.r r!r�rr`s  r'rbzSpecifierSet.__eq__�sN��&�e�c�9�-�.� ��U��,�E��E�<�0�!�!��$�$�&�%�*@�*@�*B�B�Br&c�,�t|j�S)z7Returns the number of specifiers in this specifier set.)r-r�rXs r'�__len__zSpecifierSet.__len__s���4�;�;��r&c�,�t|j�S)z�
        Returns an iterator over all the underlying :class:`Specifier` instances
        in this specifier set.

        >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str)
        [<Specifier('!=1.0.1')>, <Specifier('>=1.0.0')>]
        )r�r�rXs r'�__iter__zSpecifierSet.__iter__s���D�K�K� � r&c��|j�|jStd�|jD��|_|jS)z�Intersect all specifiers into a single sequence of version ranges.

        Empty when unsatisfiable. Callers must ensure ``self._specs``
        is non-empty.
        c3�<K�|]}|j����y�wr#)r�r�s  r'r�z+SpecifierSet._get_ranges.<locals>.<genexpr>s����1V�Q�!�,�,�.�1V�r)r�rr�rXs r'�_get_rangeszSpecifierSet._get_rangess8���<�<�#��<�<��1�1V�$�+�+�1V�V����|�|�r&c���|j}|�|S|jsd|_y|j�}|s|j�}|s'|jdurt|j��}||_|S)a�Check whether this specifier set can never be satisfied.

        Returns True if no version can satisfy all specifiers simultaneously.

        >>> SpecifierSet(">=2.0,<1.0").is_unsatisfiable()
        True
        >>> SpecifierSet(">=1.0,<2.0").is_unsatisfiable()
        False
        >>> SpecifierSet("").is_unsatisfiable()
        False
        >>> SpecifierSet("==1.0,!=1.0").is_unsatisfiable()
        True

        .. versionadded:: 26.1
        F)r�r�r,�_check_arbitrary_unsatisfiablerdr)rY�cachedr�s   r'�is_unsatisfiablezSpecifierSet.is_unsatisfiables~�� �'�'�����M��{�{�%*�D�"���%�%�'�'����8�8�:�F��$�*�*�e�3�/��0@�0@�0B�C�F�!'����
r&c�����|jD�cgc]}|jdk(s�|��}}|sy|djj��t	�fd�|ddD��ryt|dj��|jdur��
�jry|jD�cgc]}|jdk7s�|��}}|sy��yt�fd�|D��Scc}wcc}w)	aCheck === (arbitrary equality) specs for unsatisfiability.

        === uses case-insensitive string comparison, so the only candidate
        that can match ``===V`` is the literal string V.  This method
        checks whether that candidate is excluded by other specifiers.
        r�Frc3�X�K�|]!}|jj��k7���#y�wr#)r�r�)r�r�firsts  �r'r�z>SpecifierSet._check_arbitrary_unsatisfiable.<locals>.<genexpr>Ns!�����A�a�q�y�y��� �E�)�A���'*r
NTc3�@�K�|]}|j�����y�wr#r�)r�r�	candidates  �r'r�z>SpecifierSet._check_arbitrary_unsatisfiable.<locals>.<genexpr>fs�����?��q�z�z�)�,�?�s�)	r�r�r�r�rr
rdr�r)rYrr��standardr6r3s    @@r'r.z+SpecifierSet._check_arbitrary_unsatisfiableAs����!%���C�1�q�z�z�U�/B�Q�C�	�C����!��$�$�*�*�,���A�9�Q�R�=�A�A��#�9�Q�<�#7�#7�8�	�

����%��%��'�'��#�{�{�B�!�a�j�j�E�.A�A�B��B�������?�h�?�?�?�?��=D��,Cs�C�C�'C"�<C"c�0�ddlm}|j|�S)acReturn the :class:`~packaging.ranges.VersionRange` this set accepts.

        An empty set yields the full range; an unsatisfiable set yields the
        empty range. ``===`` specifiers contribute literal-string admission.

        >>> SpecifierSet(">=1.0,<2.0").to_range()
        <VersionRange '[1.0, 2.0.dev0)'>

        .. versionadded:: 26.3
        r
)�VersionRange)rr9�_from_specifier_set)rYr9s  r'�to_rangezSpecifierSet.to_rangehs��	)��/�/��5�5r&c��t|t�std��|js|jrt	d��y)Nzexpected a SpecifierSetz+set relations do not support === specifiers)r+r!r�r�r#r`s  r'�_check_relation_operandz$SpecifierSet._check_relation_operandws:���%��.��5�6�6����%�"6�"6��J�K�K�#7r&c�~�|j|�|j�j|j��S)a=Return whether every version matching this set also matches other.

        :raises ValueError:
            If either set uses ``===`` specifiers, or the two sets were
            given different ``prereleases`` arguments (unset on one side
            counts as different).
        :raises TypeError:
            If other is not a :class:`SpecifierSet`.

        >>> SpecifierSet(">=3.12,<3.13").is_subset(SpecifierSet(">=3.12"))
        True
        >>> SpecifierSet(">=3.12").is_subset(SpecifierSet(">=3.12,<3.13"))
        False

        .. versionadded:: 26.3
        )r=r;�	is_subsetr`s  r'r?zSpecifierSet.is_subset}s0��"	
�$�$�U�+��}�}��(�(����)9�:�:r&c�~�|j|�|j�j|j��S)a�Return whether every version matching other also matches this set.

        :raises ValueError:
            If either set uses ``===`` specifiers, or the two sets were
            given different ``prereleases`` arguments (unset on one side
            counts as different).
        :raises TypeError:
            If other is not a :class:`SpecifierSet`.

        >>> SpecifierSet(">=3.12").is_superset(SpecifierSet(">=3.12,<3.13"))
        True

        .. versionadded:: 26.3
        )r=r;�is_supersetr`s  r'rAzSpecifierSet.is_superset�s0��	
�$�$�U�+��}�}��*�*�5�>�>�+;�<�<r&c�~�|j|�|j�j|j��S)a.Return whether this set and other share no matching versions.

        :raises ValueError:
            If either set uses ``===`` specifiers, or the two sets were
            given different ``prereleases`` arguments (unset on one side
            counts as different).
        :raises TypeError:
            If other is not a :class:`SpecifierSet`.

        >>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.12"))
        True
        >>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.11"))
        False

        .. versionadded:: 26.3
        )r=r;�is_disjointr`s  r'rCzSpecifierSet.is_disjoint�s0��"	
�$�$�U�+��}�}��*�*�5�>�>�+;�<�<r&c�$�|j|�S)aqReturn 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�s  r'r�zSpecifierSet.__contains__�r�r&c�
�t|�}|�|r|jrd}|�|jrt|t�s|}n|}|��|js�|j
��|jrx|jr|dus|�|jdury|j}|�=|jD]}t||�}|�n|r�yy|j�x}|_t||�Stt|j|g|����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:`~packaging.version.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

        .. versionchanged:: 26.0

            With ``prereleases=None``, a prerelease now matches. A single
            version has no alternatives, so the :pep:`440` rule to accept
            prereleases when nothing else satisfies the specifiers applies.
            Earlier versions rejected it. An unparsable version now returns
            ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`.
        TFr�)r
r�r�r+rrCr�r�r�rNr,rr2r�ro)	rYrird�	installedr��
check_item�boundsr/r�s	         r'rjzSpecifierSet.contains�s��P!��&����9��1F�1F��K��?�t�2�2�:�d�G�;T��J� �J�
���'�'��
�
�%�����$�$��u�$��'�D�,=�,=��,F���\�\�F��~�
!�K�K� �D�'��g�6�E��}�� �$� � �(,�(8�(8�(:�:����&�v�w�7�7��D����j�\�{��K�L�M�Mr&c��yr#r%rls    r'rozSpecifierSet.filter$rpr&c��yr#r%rls    r'rozSpecifierSet.filter,rrr&c�&���|�|j�|j}|jr]|jr%|j���fd�|D�}t|�|�S|j}|�|j�}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:`~packaging.version.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.
        :param key:
            A callable that takes a single argument (an item from the iterable) and
            returns a version string or :class:`~packaging.version.Version`
            instance to be used for filtering.

        >>> 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']
        >>> list(SpecifierSet(">=1.2.3").filter(
        ... [{"ver": "1.2"}, {"ver": "1.3"}],
        ... key=lambda x: x["ver"]))
        [{'ver': '1.3'}]

        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']

        .. versionchanged:: 26.0

            Prerelease filtering now follows the PEP 440 recommendation of
            yielding prereleases only when no final release is present.

        .. versionchanged:: 26.1

            Added the ``key`` parameter.
        c3�N��K�|]�t��fd��D��r����y�w)c3�X�K�|]!}|j���n���d�����#y�w)NTr�r�)r�rrirns  ��r'r�z0SpecifierSet.filter.<locals>.<genexpr>.<genexpr>zs1��������
�
�3�;�4�C��I�SW�
�X��r4N)r)r�rirnrs @��r'r�z&SpecifierSet.filter.<locals>.<genexpr>ws.���������!&�����s�!%)rdr�r�r�r�r,r)rYrmrdrnr�rrs   `  @r'rozSpecifierSet.filter4s����x��4�#3�#3�#?��*�*�K��;�;��"�"������ (���1��#�{�K�K��\�\�F��~��)�)�+��#�F�H�c�;�G�G�)��3��D�Dr&r�)rzstr | Iterable[Specifier]rdr{rur|)ruztuple[Specifier, ...]rzr�)ruz)tuple[tuple[Specifier, ...], bool | None]r�rtrv)razSpecifierSet | strrur!rx)ruzIterator[Specifier]r�)rur2)ruzranges.VersionRange)raryrur|)rar!rur2)rir�rur2r�)rir�rdr{rFr{rur2r}r~rr�) rPrQrRrSr�r�rr�rdr�r�r�r�r[r^r$rbr'r)r,r0r.r;r=r?rArCr�rjr�r�ror%r&r'r!r!�s����$�I�13�#'�*(�-�*(�!�*(�
�	*(�X�����&���&��&�0�7G�rB�*A�-��@C�4 �!�
�!�F%@�N
6�L�;�(=�$=�(#�0$(�!%�	VN��VN�!�VN��	VN�

�VN�p�_�_�$(��	+�.�+�!�+��	+�

&�+��+��_�_�$(�.1�	���!��,�	�

����$(�7;�	SE��SE�!�SE�5�	SE�

�SEr&r!c#�0K�g}g}d}|D]v}t|�|n||��}|�*|r|��n"|j|�|j|��D|js|s|Ed{���d}|���c|r�f|j|��x|s|Ed{���yy7�/7��w)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r
�appendr�)rmrn�all_nonfinal�arbitrary_strings�found_finalrirIs       r'r�r��s�����!�L�#%���K��&�������T��C���>���
�!�(�(��.��#�#�D�)���#�#��,�,�,�"���J�������%�1&�6�����-��	 �s*�A B�"B�#
B�1B�B�B�B)ruz	list[str])r/ryruzTypeGuard[tuple[str, str]])r3ryruzTypeGuard[bool | None])rHr rIrrur{)r�r�rnr�rdr{rur�)rmr�rnr�rur�)<rS�
__future__rr�r�r�rrrrrr	r�rrr
rrrrrr�utilsrr�r�sys�collections.abcrrr�version_infor�typing_extensionsr�rrr$r(r0r4r5r.r�r6�__ge__�__le__rb�__ne__r<r�rNr#r�ABCMetarr r�r!r�r%r&r'�<module>r]sW���#�
�	�
���
�
�
�(����<�<�
���7�"�$�/��!�����0��C�L������%���1��I���.�.�
�.�.�
�.�.�
�.�.�	F��B���:	�z�	�S�c�k�k�S�lIO�
�IO�X�
��	0�����	�,I
E�=�I
E�X' ��' �"I�' ��' r&

Youez - 2016 - github.com/yon3zu
LinuXploit