AlkantarClanX12

Your IP : 3.141.29.162


Current Path : /opt/cloudlinux/venv/lib64/python3.11/site-packages/semver/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/semver/__pycache__/version.cpython-311.pyc

�

�܋f^���dZddlZddlZddlmZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZddlmZmZmZmZmZedeeefeeefZedegefZedd�	��Zd
edefd�Zd
�ZGd�d��ZeZ dS)z6Version handling by a semver compatible version class.�N)�wraps)�Any�Dict�Iterable�Optional�SupportsInt�Tuple�Union�cast�Callable�
Collection�Type�TypeVar�)�VersionTuple�VersionDict�VersionIterator�String�VersionPart�Version�T)�bound�operator�returnc�^��t���dddtdtf�fd���}|S)z0Wrap a Version binary op method in a type-check.�selfr�otherrc���ttttgtj�R}t
||��stS�||��S�N)r�dict�tuple�listr�__args__�
isinstance�NotImplemented)rr�comparable_typesrs   ��_/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/semver/version.py�wrapperz_comparator.<locals>.wrapper'sW���
����	
�
�_�
�
���%�!1�2�2�	"�!�!��x��e�$�$�$�)r�
Comparable�bool)rr(s` r'�_comparatorr,$sO����8�_�_�
%�i�
%�
�
%�t�
%�
%�
%�
%�
%��_�
%��Nr)c��||k||kz
S)z6Return negative if a<b, zero if a==b, positive if a>b.���a�bs  r'�_cmpr27s��
��E�a�!�e��r)c�t�eZdZdZdZed�eD����Zejd��Z	dZ
eje
�dd���ej��Z
eje
�dd���ej��Z				dFdeded
edeeeefdeeeeff
d�Zed���Zedefd���Zejd���Zedefd���Zejd���Zedefd���Zejd���Zedeefd���Zejd���Zedeefd���Zejd���Zdefd�Z de!fd�Z"de#fd�Z$e%d edefd!���Z&dGd"�Z'dGd#�Z(dGd$�Z)dHd&eeddfd'�Z*dId&eeddfd(�Z+d)e,defd*�Z-dHd+ed,eddfd-�Z.e/d)e,de0fd.���Z1e/d)e,de0fd/���Z2e/d)e,de0fd0���Z3e/d)e,de0fd1���Z4e/d)e,de0fd2���Z5e/d)e,de0fd3���Z6d4eee7fdeeeee8eeefd5fffd6�Z9defd7�Z:defd8�Z;defd9�Z<dGd:�Z=d;ede0fd<�Z>e	dJd>e?e@d?ed@e0de@fdA���ZAdBeeeefddfdC�ZBed?ede0fdD���ZCd)dde0fdE�ZDd
S)Kra�
    A semver compatible version class.

    See specification at https://semver.org.

    :param major: version when you make incompatible API changes.
    :param minor: version when you add functionality in a backwards-compatible manner.
    :param patch: version when you make backwards-compatible bug fixes.
    :param prerelease: an optional prerelease string
    :param build: an optional build string
    )�_major�_minor�_patch�_prerelease�_buildc�"�g|]}|dd���
S)rNr.)�.0�items  r'�
<listcomp>zVersion.<listcomp>Ls ��2�2�2��4����8�2�2�2r)z(?:[^\d]*(\d+)[^\d]*)+a3
            ^
            (?P<major>0|[1-9]\d*)
            (?:
                \.
                (?P<minor>0|[1-9]\d*)
                (?:
                    \.
                    (?P<patch>0|[1-9]\d*)
                ){opt_patch}
            ){opt_minor}
            (?:-(?P<prerelease>
                (?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)
                (?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*
            ))?
            (?:\+(?P<build>
                [0-9a-zA-Z-]+
                (?:\.[0-9a-zA-Z-]+)*
            ))?
            $
        �)�	opt_patch�	opt_minor�?rN�major�minor�patch�
prerelease�buildc��t|��t|��t|��d�}|���D]-\}}|dkr"td�|������.|d|_|d|_|d|_|�dnt|��|_|�dnt|��|_	dS)N)rArBrCrz1{!r} is negative. A version can only be positive.rArBrC)
�int�items�
ValueError�formatr4r5r6�strr7r8)	rrArBrCrDrE�
version_parts�name�values	         r'�__init__zVersion.__init__qs���#&�e�*�*�s�5�z�z�C�PU�J�J�W�W�
�(�.�.�0�0�	�	�K�D�%��q�y�y� �G�N�N�t�T�T�����
$�G�,���#�G�,���#�G�,���#-�#5�4�4�3�z�?�?���#�m�d�d��U������r)c�H�d�}|pd|pd}}|�d��|�d��}}d�|D��}d�|D��}t||��D]\}}|||��}|dkr|cS�tt|��t|����S)Nc���t|t��r%t|t��rt||��St|t��rdSt|t��rdSt||��S)N���r)r$rGr2r/s  r'�cmp_prerelease_tagz,Version._nat_cmp.<locals>.cmp_prerelease_tag�so���!�S�!�!�
"�j��C�&8�&8�
"��A�q�z�z�!��A�s�#�#�
"��r��A�s�#�#�
"��q��A�q�z�z�!r)r=�.c�Z�g|](}tjd|��rt|��n|��)S�z^\d+$��re�matchrG�r:�xs  r'r<z$Version._nat_cmp.<locals>.<listcomp>��3��K�K�K�a�R�X�h��2�2�9�3�q�6�6�6��K�K�Kr)c�Z�g|](}tjd|��rt|��n|��)SrVrWrZs  r'r<z$Version._nat_cmp.<locals>.<listcomp>�r\r)r)�split�zipr2�len)	�clsr0r1rS�a_parts�b_parts�sub_a�sub_b�
cmp_results	         r'�_nat_cmpzVersion._nat_cmp�s���	"�	"�	"��w�B���R�1���7�7�3�<�<���������K�K�7�K�K�K��K�K�7�K�K�K�����1�1�	(�	(�L�E�5�+�+�E�5�9�9�J��Q���!�!�!�!����A����A���'�'�'r)rc��|jS)z(The major part of a version (read-only).)r4�rs r'rAz
Version.major�����{�r)c� �td���)Nzattribute 'major' is readonly��AttributeError�rrNs  r'rAz
Version.major�����<�=�=�=r)c��|jS)z(The minor part of a version (read-only).)r5ris r'rBz
Version.minor�rjr)c� �td���)Nzattribute 'minor' is readonlyrlrns  r'rBz
Version.minor�ror)c��|jS)z(The patch part of a version (read-only).)r6ris r'rCz
Version.patch�rjr)c� �td���)Nzattribute 'patch' is readonlyrlrns  r'rCz
Version.patch�ror)c��|jS)z-The prerelease part of a version (read-only).)r7ris r'rDzVersion.prerelease�s
����r)c� �td���)Nz"attribute 'prerelease' is readonlyrlrns  r'rDzVersion.prerelease�s���A�B�B�Br)c��|jS)z(The build part of a version (read-only).)r8ris r'rEz
Version.build�rjr)c� �td���)Nzattribute 'build' is readonlyrlrns  r'rEz
Version.build�ror)c�B�|j|j|j|j|jfS)a[
        Convert the Version object to a tuple.

        .. versionadded:: 2.10.0
           Renamed :meth:`Version._astuple` to :meth:`Version.to_tuple` to
           make this function available in the public API.

        :return: a tuple with all the parts

        >>> semver.Version(5, 3, 1).to_tuple()
        (5, 3, 1, None, None)
        �rArBrCrDrEris r'�to_tuplezVersion.to_tuple�s���
�D�J��
�D�O�T�Z�P�Pr)c�z�tjd|jfd|jfd|jfd|jfd|jff��S)a
        Convert the Version object to an OrderedDict.

        .. versionadded:: 2.10.0
           Renamed :meth:`Version._asdict` to :meth:`Version.to_dict` to
           make this function available in the public API.

        :return: an OrderedDict with the keys in the order ``major``, ``minor``,
          ``patch``, ``prerelease``, and ``build``.

        >>> semver.Version(3, 2, 1).to_dict()
        OrderedDict([('major', 3), ('minor', 2), ('patch', 1), ('prerelease', None), ('build', None)])
        rArBrCrDrE)�collections�OrderedDictrArBrCrDrEris r'�to_dictzVersion.to_dict�sP���&��$�*�%��$�*�%��$�*�%��t��/��$�*�%�
�
�
�	
r)c#�>K�|���Ed{V��dS)zReturn iter(self).N)rzris r'�__iter__zVersion.__iter__�s,�����=�=�?�?�"�"�"�"�"�"�"�"�"r)�stringc�H�tj�|��}|r�tt	|�d����dz��}|�d��\}}|dt|t|��z
|���|z||d�z}|S)a
        Look for the last sequence of number(s) in a string and increment.

        :param string: the string to search for.
        :return: the incremented string

        Source:
        http://code.activestate.com/recipes/442460-increment-numbers-in-a-string/#c1
        rN)	r�_LAST_NUMBER�searchrKrG�group�span�maxr`)r�rY�next_�start�ends     r'�_increment_stringzVersion._increment_string�s����$�+�+�F�3�3���	S���E�K�K��N�N�+�+�a�/�0�0�E����A���J�E�3��:�c�#��E�
�
�"2�E�:�:�:�;�e�C�f�S�T�T�l�R�F��
r)c�F�t|��}||jdz��S)a2
        Raise the major part of the version, return a new object but leave self
        untouched.

        :return: new object with the raised major part

        >>> ver = semver.parse("3.4.5")
        >>> ver.bump_major()
        Version(major=4, minor=0, patch=0, prerelease=None, build=None)
        r)�typer4�rras  r'�
bump_majorzVersion.bump_major
s%���4�j�j���s�4�;��?�#�#�#r)c�R�t|��}||j|jdz��S)a2
        Raise the minor part of the version, return a new object but leave self
        untouched.

        :return: new object with the raised minor part

        >>> ver = semver.parse("3.4.5")
        >>> ver.bump_minor()
        Version(major=3, minor=5, patch=0, prerelease=None, build=None)
        r)r�r4r5r�s  r'�
bump_minorzVersion.bump_minors)���4�j�j���s�4�;���a��0�0�0r)c�^�t|��}||j|j|jdz��S)a2
        Raise the patch part of the version, return a new object but leave self
        untouched.

        :return: new object with the raised patch part

        >>> ver = semver.parse("3.4.5")
        >>> ver.bump_patch()
        Version(major=3, minor=4, patch=6, prerelease=None, build=None)
        r)r�r4r5r6r�s  r'�
bump_patchzVersion.bump_patch&s-���4�j�j���s�4�;���T�[�1�_�=�=�=r)�rc�tokenc���t|��}|j�|j}n |dkrd}n|�d}nt|��dz}|�|��}||j|j|j|��S)a�
        Raise the prerelease part of the version, return a new object but leave
        self untouched.

        :param token: defaults to ``'rc'``
        :return: new :class:`Version` object with the raised prerelease part.
            The original object is not modified.

        >>> ver = semver.parse("3.4.5")
        >>> ver.bump_prerelease().prerelease
        'rc.2'
        >>> ver.bump_prerelease('').prerelease
        '1'
        >>> ver.bump_prerelease(None).prerelease
        'rc.1'
        Nr=�0zrc.0�.0)r�r7rKr�r4r5r6)rr�rarDs    r'�bump_prereleasezVersion.bump_prerelease4s}��"�4�j�j����'��)�J�J�
�b�[�[��J�J�
�]��J�J��U���d�*�J��*�*�:�6�6�
��s�4�;���T�[�*�E�E�Er)c�v�t|��}|j�|j}n |dkrd}n|�d}nt|��dz}|�|��}|j�|j}n |dkrd}n|�d}nt|��dz}|�|��}||j|j|j|j|��S)a�
        Raise the build part of the version, return a new object but leave self
        untouched.

        :param token: defaults to ``'build'``
        :return: new :class:`Version` object with the raised build part.
            The original object is not modified.

        >>> ver = semver.parse("3.4.5-rc.1+build.9")
        >>> ver.bump_build()
        Version(major=3, minor=4, patch=5, prerelease='rc.1', build='build.10')
        Nr=r�zbuild.0r�)r�r8rKr�r4r5r6r7)rr�rarEs    r'�
bump_buildzVersion.bump_buildRs����4�j�j���;�"��K�E�E�
�b�[�[��E�E�
�]��E�E���J�J��%�E��%�%�e�,�,���;�"��K�E�E�
�b�[�[��E�E�
�]��E�E���J�J��%�E��%�%�e�,�,���s�4�;���T�[�$�:J�E�R�R�Rr)rc�j�t|��}t|tj��r|�|��}nwt|t
��r	|di|��}nYt|ttf��r||�}n7t||��s'td|j	�dt|�������|�
��dd�}|�
��dd�}t||��}|r|S|j|j}}|�
||��}|sdS|sdS|sdS|S)	a�
        Compare self with other.

        :param other: the second version
        :return: The return value is negative if ver1 < ver2,
             zero if ver1 == ver2 and strictly positive if ver1 > ver2

        >>> semver.compare("2.0.0")
        -1
        >>> semver.compare("1.0.0")
        1
        >>> semver.compare("2.0.0")
        0
        >>> semver.compare(dict(major=2, minor=0, patch=0))
        0
        z+Expected str, bytes, dict, tuple, list, or z instance, but got N�rrrRr.)r�r$rr#�parser r!r"�	TypeError�__name__rzr2rDrg)	rrra�v1�v2r[�rc1�rc2�rccmps	         r'�comparezVersion.compareys_��"�4�j�j���e�V�_�-�-�
	��I�I�e�$�$�E�E�
��t�
$�
$�	��C�L�L�%�L�L�E�E�
���t�}�
-�
-�	��C��K�E�E��E�3�'�'�	��)�c�l�)�)���;�;�)�)���
�
�]�]�_�_�R�a�R�
 ��
�^�^�
�
�b�q�b�
!����R�L�L���	��H��?�E�$4�S���
�
�c�3�'�'���	��1��	��1��	��2��r)�part�prerelease_tokenc���t|��}|jdd�}||vrtd|�d|�����|}|js|jrN|dks1|dkr|jdks |dkr1|j|jcxkrdkrnn|�dd�	��S||jdd
�vrt|d|z����S|js|�	��}|�
|��S)a�
        Determines next version, preserving natural order.

        .. versionadded:: 2.10.0

        This function is taking prereleases into account.
        The "major", "minor", and "patch" raises the respective parts like
        the ``bump_*`` functions. The real difference is using the
        "prerelease" part. It gives you the next patch version of the
        prerelease, for example:

        >>> str(semver.parse("0.1.4").next_version("prerelease"))
        '0.1.5-rc.1'

        :param part: One of "major", "minor", "patch", or "prerelease"
        :param prerelease_token: prefix string of prerelease, defaults to 'rc'
        :return: new object with the appropriate part raised
        NrRzInvalid part. Expected one of z
, but got rCrBrrA)rDrEr��bump_)r��NAMESrIrDrErCrB�replace�getattrr�r�)rr�r�ra�
validparts�versions      r'�next_versionzVersion.next_version�s1��&�4�j�j���Y�s��s�^�
��z�!�!��O��O�O�t�O�O���
�����	@�'�-�	@��G�O�O�����G�M�Q�$6�$6�����G�M�W�]�$G�$G�$G�$G�a�$G�$G�$G�$G�$G��?�?�d�$�?�?�?�?��3�9�R�a�R�=� � �3�7�7�G�d�N�3�3�5�5�5��!�	+��(�(�*�*�G��&�&�'7�8�8�8r)c�4�|�|��dkS�Nr�r��rrs  r'�__eq__zVersion.__eq__�����|�|�E�"�"�a�'�'r)c�4�|�|��dkSr�r�r�s  r'�__ne__zVersion.__ne__�r�r)c�4�|�|��dkSr�r�r�s  r'�__lt__zVersion.__lt__�����|�|�E�"�"�Q�&�&r)c�4�|�|��dkSr�r�r�s  r'�__le__zVersion.__le__�r�r)c�4�|�|��dkSr�r�r�s  r'�__gt__zVersion.__gt__�r�r)c�4�|�|��dkSr�r�r�s  r'�__ge__zVersion.__ge__�r�r)�index.c
��t|t��rt||dz��}tt|��}t|t��r|j�|jdks|j�|jdkrt
d���ttd�tt|�
��|������}t|��dkr|dS|st
d���|S)a[
        self.__getitem__(index) <==> self[index] Implement getitem.

        If the part  requested is undefined, or a part of the range requested
        is undefined, it will throw an index error.
        Negative indices are not supported.

        :param index: a positive integer indicating the
               offset or a :func:`slice` object
        :raises IndexError: if index is beyond the range or a part is None
        :return: the requested part of the version at position index

        >>> ver = semver.Version.parse("3.4.5")
        >>> ver[0], ver[1], ver[2]
        (3, 4, 5)
        rNrz Version index cannot be negativec�
�|duSrr.)�ps r'�<lambda>z%Version.__getitem__.<locals>.<lambda>
s
��Q�d�]�r)zVersion part undefined)r$rG�slicerr��stop�
IndexErrorr!�filterrrzr`)rr�r�s   r'�__getitem__zVersion.__getitem__�s���&�e�S�!�!�	,��%����+�+�E��U�E�"�"��
�u�e�$�$�	A���(�U�[�1�_�_��
�&�5�:��>�>��?�@�@�@���*�*�D��4�=�=�?�?�5�;Q�,R�,R�S�S�
�
���t�9�9��>�>���7�N��	7��5�6�6�6��r)c��d�d�|������D����}t|��j�d|�d�S)N�, c3�*K�|]\}}|�d|��V��dS)�=Nr.)r:�key�vals   r'�	<genexpr>z#Version.__repr__.<locals>.<genexpr>s1����R�R�x�s�C����c�c�*�R�R�R�R�R�Rr)�(�))�joinr~rHr�r�)r�ss  r'�__repr__zVersion.__repr__sT���I�I�R�R�4�<�<�>�>�;O�;O�;Q�;Q�R�R�R�R�R����:�:�.�.�.����2�2r)c��d|j|j|jfz}|jr
|d|jzz
}|jr
|d|jzz
}|S)Nz%d.%d.%dz-%sz+%sry)rr�s  r'�__str__zVersion.__str__sT����
�D�J��
�C�C���?�	/��u�t��.�.�G��:�	*��u�t�z�)�)�G��r)c�T�t|���dd���S)N�)�hashrzris r'�__hash__zVersion.__hash__s!���D�M�M�O�O�B�Q�B�'�(�(�(r)c�X�t|��}||j|j|j��S)z�
        Remove any prerelease and build metadata from the version.

        :return: a new instance with the finalized version string

        >>> str(semver.Version.parse('1.2.3-rc.5').finalize_version())
        '1.2.3'
        )r�rArBrCr�s  r'�finalize_versionzVersion.finalize_version"s)���4�j�j���s�4�:�t�z�4�:�6�6�6r)�
match_exprc��|dd�}|dvr|dd�}nB|r|ddvr|d}|dd�}n#|r|ddvrd}|}ntd	|z���d
ddd
ddd�}||}|�|��}||vS)a�
        Compare self to match a match expression.

        :param match_expr: optional operator and version; valid operators are
              ``<``   smaller than
              ``>``   greater than
              ``>=``  greator or equal than
              ``<=``  smaller or equal than
              ``==``  equal
              ``!=``  not equal
        :return: True if the expression matches the version, otherwise False

        >>> semver.Version.parse("2.0.0").match(">=1.0.0")
        True
        >>> semver.Version.parse("1.0.0").match(">1.0.0")
        False
        >>> semver.Version.parse("4.0.4").match("4.0.4")
        True
        N�)�>=�<=�==�!=r)�>�<r�
0123456789r�z}match_expr parameter should be in format <op><ver>, where <op> is one of ['<', '>', '==', '<=', '>=', '!=']. You provided: %r)r)rR)r)rRr)rr)rRr)r�r�r�r�r�r�)rIr�)rr��prefix�
match_version�possibilities_dict�
possibilities�cmp_ress       r'rYz
Version.match.s���(�B�Q�B����-�-�-�&�q�r�r�N�M�M�
�	��q�	�Z�/�/��A�Y�F�&�q�r�r�N�M�M�
�		�J�q�M�\�9�9��F�&�M�M��#�&0�0���
�������

�
��+�6�2�
��,�,�}�-�-���-�'�'r)Frar��optional_minor_and_patchc���t|t��r|�d��}n9t|tj��stdt
|��z���|r|j�|��}n|j	�|��}|�t|�d����|���}|dsd|d<|dsd|d<|di|��S)	a�
        Parse version string to a Version instance.

        .. versionchanged:: 2.11.0
           Changed method from static to classmethod to
           allow subclasses.
        .. versionchanged:: 3.0.0
           Added optional parameter ``optional_minor_and_patch`` to allow
           optional minor and patch parts.

        :param version: version string
        :param optional_minor_and_patch: if set to true, the version string to parse            can contain optional minor and patch parts. Optional parts are set to zero.
           By default (False), the version string to parse has to follow the semver
           specification.
        :return: a new :class:`Version` instance
        :raises ValueError: if version is invalid
        :raises TypeError: if version contains the wrong type

        >>> semver.Version.parse('3.4.5-pre.2+build.4')
        Version(major=3, minor=4, patch=5, prerelease='pre.2', build='build.4')
        zUTF-8znot expecting type '%s'Nz is not valid SemVer stringrBrrCr.)r$�bytes�decoderr#r�r��_REGEX_OPTIONAL_MINOR_AND_PATCHrY�_REGEXrI�	groupdict)rar�r�rY�matched_version_partss     r'r�z
Version.parseas��6�g�u�%�%�	G��n�n�W�-�-�G�G��G�V�_�5�5�	G��5��W�
�
�E�F�F�F�#�	.��7�=�=�g�F�F�E�E��J�$�$�W�-�-�E��=���D�D�D�E�E�E�05���0A�0A��$�W�-�	/�-.�!�'�*�$�W�-�	/�-.�!�'�*��s�+�+�*�+�+�+r)�partsc�X�|���}|�|��	tdi|��S#t$rht	|��t	|�����z
}dt|��d�|��fz}t|���wxYw)a�
        Replace one or more parts of a version and return a new
        :class:`Version` object, but leave self untouched

        .. versionadded:: 2.9.0
           Added :func:`Version.replace`

        :param parts: the parts to be updated. Valid keys are:
          ``major``, ``minor``, ``patch``, ``prerelease``, or ``build``
        :return: the new :class:`~semver.version.Version` object with
          the changed parts
        :raises TypeError: if ``parts`` contain invalid keys
        z3replace() got %d unexpected keyword argument(s): %sr�Nr.)r~�updaterr��setr`r�)rr�r��unknownkeys�errors     r'r�zVersion.replace�s����,�,�.�.�����u����	#��%�%�W�%�%�%���	#�	#�	#��e�*�*�s�4�<�<�>�>�':�':�:�K�I��K� � ��	�	�+�&�&�M��E��E�"�"�"�
	#���s
�7�A2B)c�T�	|�|��dS#t$rYdSwxYw)ab
        Check if the string is a valid semver version.

        .. versionadded:: 2.9.1

        .. versionchanged:: 3.0.0
           Renamed from :meth:`~semver.version.Version.isvalid`

        :param version: the version string to check
        :return: True if the version string is a valid semver version, False
                 otherwise.
        TF)r�rI)rar�s  r'�is_validzVersion.is_valid�s@��	��I�I�g�����4���	�	�	��5�5�	���s��
'�'c�.�t|t��stdt|�������d|jcxkr|jkrnn|dd�|dd�krdS|j|jko|j|jko|j|jkS)aC
        Check if current version is compatible with other version.

        The result is True, if either of the following is true:

        * both versions are equal, or
        * both majors are equal and higher than 0. Same for both minors.
          Both pre-releases are equal, or
        * both majors are equal and higher than 0. The minor of b's
          minor version is higher then a's. Both pre-releases are equal.

        The algorithm does *not* check patches.

        .. versionadded:: 3.0.0

        :param other: the version to check for compatibility
        :return: True, if ``other`` is compatible with the old version,
                 otherwise False

        >>> Version(1, 1, 0).is_compatible(Version(1, 0, 0))
        False
        >>> Version(1, 0, 0).is_compatible(Version(1, 1, 0))
        True
        z Expected a Version type but got rNr�F)r$rr�r�rArBrDr�s  r'�
is_compatiblezVersion.is_compatible�s���2�%��)�)�	N��L�t�E�{�{�L�L�M�M�M�
���*�*�*�*�u�{�*�*�*�*�*��b�q�b��U�2�A�2�Y�1F�1F��5��Z�5�;�
&�
6����
�*�
6���E�$4�4�	
r))rrNN)rr)r�)rE)F)Er��
__module__�__qualname__�__doc__�	__slots__r!r�rX�compiler��_REGEX_TEMPLATErJ�VERBOSEr�r�rrr
rrGrO�classmethodrg�propertyrA�setterrBrCrKrDrErrzrr~rr��staticmethodr�r�r�r�r�r�r*r�r�r,r+r�r�r�r�r�r�r�r	r�r�r�r�r�rYrrr�r�r�rr.r)r'rr<s�������
�
�H�I�
�E�2�2�	�2�2�2�3�3�E��2�:�7�8�8�L��O�,�R�Z�����r��:�:�
�
���F�
'1�b�j�������<�<�
�
�'�'�#���37�.2�
<�<��<��<��	<�
�U�6�3�;�/�0�<���f�c�k�*�+�
<�<�<�<�.�(�(��[�(�,��s�����X���\�>�>��\�>���s�����X���\�>�>��\�>���s�����X���\�>�>��\�>�� �H�S�M� � � ��X� ���C�C���C���x��}�����X���\�>�>��\�>�
Q�,�
Q�
Q�
Q�
Q�
��
�
�
�
�2#�/�#�#�#�#���#��#�����\��"$�$�$�$�1�1�1�1�>�>�>�>�F�F�X�c�]�F�i�F�F�F�F�<%S�%S���
�%S�I�%S�%S�%S�%S�N.�Z�.�C�.�.�.�.�`(9�(9��(9��(9�y�(9�(9�(9�(9�T�(�J�(�4�(�(�(��[�(��(�J�(�4�(�(�(��[�(��'�J�'�4�'�'�'��[�'��(�J�(�4�(�(�(��[�(��'�J�'�4�'�'�'��[�'��(�J�(�4�(�(�(��[�(�&��3��:�&�&�	�s�H�S�M�5��s�C�x��#�)=�#>�>�	?�&�&�&�&�P3�#�3�3�3�3�������)�#�)�)�)�)�
7�
7�
7�
7�1(��1(��1(�1(�1(�1(�f�HM�,,�,,�
�!�W�,,�%�,,�AE�,,�	
�,,�,,�,,��[�,,�\#�u�S�(�3�-�%7�8�#�Y�#�#�#�#�4��s��t�����[��&$
�9�$
��$
�$
�$
�$
�$
�$
r))!rr|rX�	functoolsr�typingrrrrrr	r
rrr
rr�_typesrrrrrrKr*r+�
Comparatorrr,r2r�VersionInfor.r)r'�<module>rs���<�<�����	�	�	�	�������
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
����������������9�d�3��#3�4�j��6M�s�R�
S�
�
�y�*�-�t�3�
4�
��G�C�y�!�!�!���*�������&���
f

�f

�f

�f

�f

�f

�f

�f

�T���r)