HEX

File: //usr/libexec/oracle-cloud-agent/plugins/osms/packaging/version.pyc
a

i��fF?�
@s�dZddlmZddlZddlZddlmZmZmZm	Z	m
Z
mZddlm
Z
mZmZmZgd�Ze
eeefdfZeeee
eeffZeee
ee
eefe
eeeefffdffZe
ee
edfeeeefZeeegefZGd	d
�d
e�Zddd
�dd�ZGdd�de�ZGdd�d�ZdZeZ Gdd�de�Z!dddd�dd�Z"e�#d�Z$ddd�dd �Z%d!d"ddddd#d$�d%d&�Z&dS)'zB
.. testsetup::

    from packaging.version import parse, Version
�)�annotationsN)�Any�Callable�
NamedTuple�SupportsInt�Tuple�Union�)�Infinity�InfinityType�NegativeInfinity�NegativeInfinityType)�VERSION_PATTERN�parse�Version�InvalidVersion.c@s>eZdZUded<ded<ded<ded<ded<d	ed
<dS)�_Version�int�epoch�tuple[int, ...]�release�tuple[str, int] | None�dev�pre�post�LocalType | None�localN)�__name__�
__module__�__qualname__�__annotations__�r!r!�u/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/packaging/version.pyr&s
r�strr��version�returncCst|�S)z�Parse the given version string.

    >>> parse('1.0.dev1')
    <Version('1.0.dev1')>

    :param version: The version string to parse.
    :raises InvalidVersion: When the version string is not a valid version.
    )r)r%r!r!r"r/s	rc@seZdZdZdS)rz�Raised when a version string is not a valid version.

    >>> Version("invalid")
    Traceback (most recent call last):
        ...
    packaging.version.InvalidVersion: Invalid version: 'invalid'
    N)rrr�__doc__r!r!r!r"r;src@s�eZdZUded<dd�dd�Zddd�d	d
�Zddd�dd�Zd
dd�dd�Zddd�dd�Zddd�dd�Z	d
dd�dd�Z
dS)�_BaseVersionztuple[Any, ...]�_keyr�r&cCs
t|j�S�N)�hashr)��selfr!r!r"�__hash__Hsz_BaseVersion.__hash__�bool)�otherr&cCst|t�stS|j|jkSr+��
isinstancer(�NotImplementedr)�r.r1r!r!r"�__lt__Ns
z_BaseVersion.__lt__cCst|t�stS|j|jkSr+r2r5r!r!r"�__le__Ts
z_BaseVersion.__le__�objectcCst|t�stS|j|jkSr+r2r5r!r!r"�__eq__Zs
z_BaseVersion.__eq__cCst|t�stS|j|jkSr+r2r5r!r!r"�__ge__`s
z_BaseVersion.__ge__cCst|t�stS|j|jkSr+r2r5r!r!r"�__gt__fs
z_BaseVersion.__gt__cCst|t�stS|j|jkSr+r2r5r!r!r"�__ne__ls
z_BaseVersion.__ne__N)rrrr r/r6r7r9r:r;r<r!r!r!r"r(Es
r(a�
    v?
    (?:
        (?:(?P<epoch>[0-9]+)!)?                           # epoch
        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
        (?P<pre>                                          # pre-release
            [-_\.]?
            (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
            [-_\.]?
            (?P<pre_n>[0-9]+)?
        )?
        (?P<post>                                         # post release
            (?:-(?P<post_n1>[0-9]+))
            |
            (?:
                [-_\.]?
                (?P<post_l>post|rev|r)
                [-_\.]?
                (?P<post_n2>[0-9]+)?
            )
        )?
        (?P<dev>                                          # dev release
            [-_\.]?
            (?P<dev_l>dev)
            [-_\.]?
            (?P<dev_n>[0-9]+)?
        )?
    )
    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
c@s^eZdZUdZe�dedejejB�Z	de
d<ddd�d	d
�Zdd�dd
�Zdd�dd�Z
edd�dd��Zedd�dd��Zedd�dd��Zedd�dd��Zedd�dd��Zedd�dd ��Zedd�d!d"��Zedd�d#d$��Zed%d�d&d'��Zed%d�d(d)��Zed%d�d*d+��Zedd�d,d-��Zedd�d.d/��Zedd�d0d1��Zd2S)3ra�This class abstracts handling of a project's versions.

    A :class:`Version` instance is comparison aware and can be compared and
    sorted using the standard Python interfaces.

    >>> v1 = Version("1.0a5")
    >>> v2 = Version("1.0")
    >>> v1
    <Version('1.0a5')>
    >>> v2
    <Version('1.0')>
    >>> v1 < v2
    True
    >>> v1 == v2
    False
    >>> v1 > v2
    False
    >>> v1 >= v2
    False
    >>> v1 <= v2
    True
    z^\s*z\s*$�CmpKeyr)r#�Noner$c
Cs�|j�|�}|s td|�d���t|�d�r:t|�d��ndtdd�|�d��d�D��t|�d	�|�d
��t|�d�|�d�p�|�d
��t|�d�|�d��t	|�d��d�|_
t|j
j|j
j
|j
j|j
j|j
j|j
j�|_dS)aCInitialize a Version object.

        :param version:
            The string representation of a version which will be parsed and normalized
            before use.
        :raises InvalidVersion:
            If the ``version`` does not conform to PEP 440 in any way then this
            exception will be raised.
        zInvalid version: '�'rrcss|]}t|�VqdSr+)r��.0�ir!r!r"�	<genexpr>��z#Version.__init__.<locals>.<genexpr>r�.�pre_l�pre_n�post_l�post_n1�post_n2�dev_l�dev_nr)rrrrrrN)�_regex�searchrr�groupr�tuple�split�_parse_letter_version�_parse_local_version�_version�_cmpkeyrrrrrrr))r.r%�matchr!r!r"�__init__�s*���zVersion.__init__r*cCsd|�d�S)z�A representation of the Version that shows all internal state.

        >>> Version('1.0.0')
        <Version('1.0.0')>
        z
<Version('z')>r!r-r!r!r"�__repr__�szVersion.__repr__cCs�g}|jdkr |�|j�d��|�d�dd�|jD���|jdurb|�d�dd�|jD���|jdur~|�d	|j���|jdur�|�d
|j���|jdur�|�d|j���d�|�S)zA string representation of the version that can be rounded-tripped.

        >>> str(Version("1.0a5"))
        '1.0a5'
        r�!rEcss|]}t|�VqdSr+�r#�rA�xr!r!r"rC�rDz"Version.__str__.<locals>.<genexpr>N�css|]}t|�VqdSr+rZr[r!r!r"rC�rDz.postz.dev�+)r�append�joinrrrrr�r.�partsr!r!r"�__str__�s




zVersion.__str__rcCs|jjS)zThe epoch of the version.

        >>> Version("2.0.0").epoch
        0
        >>> Version("1!2.0.0").epoch
        1
        )rTrr-r!r!r"rs	z
Version.epochrcCs|jjS)adThe components of the "release" segment of the version.

        >>> Version("1.2.3").release
        (1, 2, 3)
        >>> Version("2.0.0").release
        (2, 0, 0)
        >>> Version("1!2.0.0.post0").release
        (2, 0, 0)

        Includes trailing zeroes but not the epoch or any pre-release / development /
        post-release suffixes.
        )rTrr-r!r!r"rszVersion.releasercCs|jjS)aThe pre-release segment of the version.

        >>> print(Version("1.2.3").pre)
        None
        >>> Version("1.2.3a1").pre
        ('a', 1)
        >>> Version("1.2.3b1").pre
        ('b', 1)
        >>> Version("1.2.3rc1").pre
        ('rc', 1)
        )rTrr-r!r!r"r&s
zVersion.prez
int | NonecCs|jjr|jjdSdS)z�The post-release number of the version.

        >>> print(Version("1.2.3").post)
        None
        >>> Version("1.2.3.post1").post
        1
        r	N)rTrr-r!r!r"r5s	zVersion.postcCs|jjr|jjdSdS)z�The development number of the version.

        >>> print(Version("1.2.3").dev)
        None
        >>> Version("1.2.3.dev1").dev
        1
        r	N)rTrr-r!r!r"r@s	zVersion.dev�
str | NonecCs(|jjr d�dd�|jjD��SdSdS)z�The local version segment of the version.

        >>> print(Version("1.2.3").local)
        None
        >>> Version("1.2.3+abc").local
        'abc'
        rEcss|]}t|�VqdSr+rZr[r!r!r"rCUrDz Version.local.<locals>.<genexpr>N)rTrr`r-r!r!r"rKs	z
Version.localcCst|��dd�dS)z�The public portion of the version.

        >>> Version("1.2.3").public
        '1.2.3'
        >>> Version("1.2.3+abc").public
        '1.2.3'
        >>> Version("1.2.3+abc.dev1").public
        '1.2.3'
        r^r	r)r#rQr-r!r!r"�publicYszVersion.publiccCsFg}|jdkr |�|j�d��|�d�dd�|jD���d�|�S)a]The "base version" of the version.

        >>> Version("1.2.3").base_version
        '1.2.3'
        >>> Version("1.2.3+abc").base_version
        '1.2.3'
        >>> Version("1!1.2.3+abc.dev1").base_version
        '1!1.2.3'

        The "base version" is the public version of the project without any pre or post
        release markers.
        rrYrEcss|]}t|�VqdSr+rZr[r!r!r"rC{rDz'Version.base_version.<locals>.<genexpr>r])rr_r`rrar!r!r"�base_versionfs

zVersion.base_versionr0cCs|jdup|jduS)aTWhether this version is a pre-release.

        >>> Version("1.2.3").is_prerelease
        False
        >>> Version("1.2.3a1").is_prerelease
        True
        >>> Version("1.2.3b1").is_prerelease
        True
        >>> Version("1.2.3rc1").is_prerelease
        True
        >>> Version("1.2.3dev1").is_prerelease
        True
        N)rrr-r!r!r"�
is_prereleaseszVersion.is_prereleasecCs
|jduS)z�Whether this version is a post-release.

        >>> Version("1.2.3").is_postrelease
        False
        >>> Version("1.2.3.post1").is_postrelease
        True
        N)rr-r!r!r"�is_postrelease�s	zVersion.is_postreleasecCs
|jduS)z�Whether this version is a development release.

        >>> Version("1.2.3").is_devrelease
        False
        >>> Version("1.2.3.dev1").is_devrelease
        True
        N)rr-r!r!r"�
is_devrelease�s	zVersion.is_devreleasecCst|j�dkr|jdSdS)zqThe first item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").major
        1
        r	r��lenrr-r!r!r"�major�sz
Version.majorcCst|j�dkr|jdSdS)z�The second item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").minor
        2
        >>> Version("1").minor
        0
        �r	rrjr-r!r!r"�minor�s	z
Version.minorcCst|j�dkr|jdSdS)z�The third item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").micro
        3
        >>> Version("1").micro
        0
        �rmrrjr-r!r!r"�micro�s	z
Version.microN)rrrr'�re�compiler�VERBOSE�
IGNORECASErMr rWrXrc�propertyrrrrrrrerfrgrhrirlrnrpr!r!r!r"r�sD
&!






rdz str | bytes | SupportsInt | Noner)�letter�numberr&cCsv|rZ|durd}|��}|dkr&d}n(|dkr4d}n|dvrBd}n|dvrNd	}|t|�fS|sr|rrd	}|t|�fSdS)
Nr�alpha�a�beta�b)�cr�preview�rc)�rev�rr)�lowerr)rvrwr!r!r"rR�s"rRz[\._-]r)rr&cCs$|dur tdd�t�|�D��SdS)zR
    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
    Ncss&|]}|��s|��nt|�VqdSr+)�isdigitr�r)rA�partr!r!r"rC�s�z'_parse_local_version.<locals>.<genexpr>)rP�_local_version_separatorsrQ)rr!r!r"rS�s
�rSrrr=)rrrrrrr&cCs�tttt�dd�t|�����}|dur>|dur>|dur>t}n|durLt}n|}|dur^t}n|}|durpt}	n|}	|dur�t}
ntdd�|D��}
|||||	|
fS)NcSs|dkS)Nrr!)r\r!r!r"�<lambda>rDz_cmpkey.<locals>.<lambda>css(|] }t|t�r|dfnt|fVqdS)r]N)r3rrr@r!r!r"rC/sz_cmpkey.<locals>.<genexpr>)rP�reversed�list�	itertools�	dropwhilerr
)rrrrrr�_release�_pre�_post�_dev�_localr!r!r"rU�s(
�	�rU)'r'�
__future__rr�rq�typingrrrrrr�_structuresr
rrr
�__all__rr#�	LocalType�CmpPrePostDevType�CmpLocalTyper=r0�VersionComparisonMethodrr�
ValueErrorrr(�_VERSION_PATTERNrrrRrrr�rSrUr!r!r!r"�<module>sH *��
��	
0
'#