old-saburly-wagtail-web/env/lib/python3.10/site-packages/packaging/__pycache__/version.cpython-310.pyc

o
<00><><EFBFBD>fF?<00>
@
sh
dZd
dl
mZ
d
dlZd
dlZd
dlmZmZmZm	Z	m
Z
mZ
ddlm
Z
mZmZmZ
gd<07>
Ze
eeefdfZeeee
eeffZeee
ee
eefe
eeeefffdffZe
ee
edfeeeefZeeegefZGd	d
<EFBFBD>d
e<08>Zd-dd<10>ZGdd<12>de<1C>ZGdd<14>d<14>ZdZeZ 	Gdd<0E>de<1E>Z!d.dd<1D>Z"e<04>#d<1E>
Z$d/d!d"<22>Z%d0d+d,<2C>Z&dS)1zB
.. testsetup::

    from packaging.version import parse, Version
<EFBFBD>)
<01>annotationsN)<06>Any<6E>Callable<6C>
NamedTuple<EFBFBD>SupportsInt<6E>Tuple<6C>Union<6F>
)<04>Infinity<74>InfinityType<70>NegativeInfinity<74>NegativeInfinityType)<04>VERSION_PATTERN<52>parse<73>Version<6F>InvalidVersion.c@
s>eZ
dZUd
ed<ded<ded<ded<ded<d	ed
<dS)<0C>_Version<6F>int<6E>epoch<63>tuple[int, ...]<5D>release<73>tuple[str, int] | None<6E>dev<65>pre<72>post<73>LocalType | None<6E>localN)<04>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__annotations__<5F>r!r!<00>S/home/amir/Desktop/saburlyweb/env/lib/python3.10/site-packages/packaging/version.pyr&s






r<00>version<6F>str<74>returnrc

C
st|<00>
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/<00>	rc
@
seZ
dZd
ZdS)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<00>__doc__r!r!r!r"r;s
rc@
s\eZ
dZUd
ed<ddd<06>Zdd	d
<EFBFBD>Zddd<0C>Zddd<0F>Zddd<11>Zddd<13>Z	ddd<15>Z
dS)<1A>_BaseVersionztuple[Any, ...]<5D>_keyr%rc

C
s
t|j
<01>
S<00>
N)<02>hashr)<00>
<01>selfr!r!r"<00>__hash__Hs

z_BaseVersion.__hash__<5F>other<65>boolcC
st|
t
<01>stS|j|
jkSr*<00><04>
isinstancer(<00>NotImplementedr)<00>r-r/r!r!r"<00>__lt__N<00>


z_BaseVersion.__lt__cC
st|
t
<01>stS|j|
jk
Sr*r1r4r!r!r"<00>__le__Tr6z_BaseVersion.__le__<5F>objectcC
st|
t
<01>stS|j|
jkSr*r1r4r!r!r"<00>__eq__Zr6z_BaseVersion.__eq__cC
st|
t
<01>stS|j|
jkSr*r1r4r!r!r"<00>__ge__`r6z_BaseVersion.__ge__cC
st|
t
<01>stS|j|
jkSr*r1r4r!r!r"<00>__gt__fr6z_BaseVersion.__gt__cC
st|
t
<01>stS|j|
jkSr*r1r4r!r!r"<00>__ne__lr6z_BaseVersion.__ne__N<5F>r%r)r/r(r%r0)r/r8r%r0)rrrr r.r5r7r9r: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
eZ
dZUd
Ze<04>dedejejB<00>Z	de
d<d3d
d<0B>Zd4dd
<0A>Zd4dd<0F>Z
ed5dd<12><04>
Zed6dd<15><04>
Zed7dd<18><04>
Zed8dd<1B><04>
Zed8dd<1D><04>
Zed9dd <20><04>
Zed4d!d"<22><04>
Zed4d#d$<24><04>
Zed:d&d'<27><04>
Zed:d(d)<29><04>
Zed:d*d+<2B><04>
Zed5d,d-<2D><04>
Zed5d.d/<2F><04>
Zed5d0d1<64><04>
Zd2S);ra<>
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*$<24>CmpKeyr)r#r$r%<00>Nonec
C
s<>|j<00>
|
<01>
}|std
|
<01>d<02><03>
<01>
t|<02>d<03>
rt|<02>d<03>
<01>
n
dtdd<06>|<02>d<07>
<01>d<08>
D<00>
<01>
t|<02>d	<09>
|<02>d
<EFBFBD>
<01>t|<02>d<0B>
|<02>d<0C>
pD|<02>d
<0A>
<01>t|<02>d<0E>
|<02>d<0F>
<01>t	|<02>d<10>
<01>
d<11>|_
t|j
j|j
j
|j
j|j
j|j
j|j
j<11>|_dS)aC
Initialize 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: '<27>
'rr
c
s
<01><00>|]}
t|
<01>
V
qdSr*)
r<00><02>.0<EFBFBD>
ir!r!r"<00>	<genexpr><3E><00><02>z#Version.__init__.<locals>.<genexpr>r<00>
.<2E>pre_l<5F>pre_n<5F>post_l<5F>post_n1<6E>post_n2<6E>dev_l<5F>dev_nr)rrrrrrN)<13>_regex<65>searchrr<00>groupr<00>tuple<6C>split<69>_parse_letter_version<6F>_parse_local_version<6F>_version<6F>_cmpkeyrrrrrrr))r-r#<00>matchr!r!r"<00>__init__<5F>s*






<02>
<08>






<EFBFBD>zVersion.__init__c

C
sd
|<00>d<02>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"<00>__repr__<5F>szVersion.__repr__c
C
s<>g}
|jd
kr|
<01>
|j<00>d<02><02>

|
<01>
d<03>dd<05>|jD<00>
<01>
<01>

|jdu
r1|
<01>
d<07>dd<05>|jD<00>
<01>
<01>

|jdu
r?|
<01>
d	|j<05><00><02>

|jdu
rM|
<01>
d
|j<06><00><02>

|jdu
r[|
<01>
d|j<07><00><02>

d<07>|
<01>
S)zA string representation of the version that can be rounded-tripped.

        >>> str(Version("1.0a5"))
        '1.0a5'
        r
<00>
!rGc
s
rAr*<00>
r$<00>rC<00>
xr!r!r"rE<00>rFz"Version.__str__.<locals>.<genexpr>N<>c
s
rAr*r\r]r!r!r"rE<00>rFz.postz.dev<65>
+)r<00>append<6E>joinrrrrr<00>r-<00>partsr!r!r"<00>__str__<5F>s










zVersion.__str__rc


C
<01>|jj
S)
zThe epoch of the version.

        >>> Version("2.0.0").epoch
        0
        >>> Version("1!2.0.0").epoch
        1
        )rVrr,r!r!r"r
r&z
Version.epochrc


C
rf)
ad
The 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.
        )rVrr,r!r!r"r
szVersion.releaserc


C
rf)
a
The 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)
        )rVrr,r!r!r"r&
s
zVersion.pre<72>
int | Nonec

C
<01>|jj
r
|jj
d
SdS)z<>The post-release number of the version.

        >>> print(Version("1.2.3").post)
        None
        >>> Version("1.2.3.post1").post
        1
        r	N)rVrr,r!r!r"r5
<00>	zVersion.postc

C
rh)z<>The development number of the version.

        >>> print(Version("1.2.3").dev)
        None
        >>> Version("1.2.3.dev1").dev
        1
        r	N)rVrr,r!r!r"r@
rizVersion.dev<65>
str | Nonec

C
s$|jj
rd
<01>dd<03>|jj
D<00>
<01>
SdS)z<>The local version segment of the version.

        >>> print(Version("1.2.3").local)
        None
        >>> Version("1.2.3+abc").local
        'abc'
        rGc
s
rAr*r\r]r!r!r"rEU
rFz Version.local.<locals>.<genexpr>N)rVrrbr,r!r!r"rK
s	
z
Version.localc

C
st|<00>
<01>
d
d<02>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$rSr,r!r!r"<00>publicY
szVersion.publicc
C
sFg}
|jd
kr|
<01>
|j<00>d<02><02>

|
<01>
d<03>dd<05>|jD<00>
<01>
<01>

d<06>|
<01>
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.
        r
r[rGc
s
rAr*r\r]r!r!r"rE{
rFz'Version.base_version.<locals>.<genexpr>r_)rrarbrrcr!r!r"<00>base_versionf
s



zVersion.base_versionr0c

C
s|jd
u
p	|j
d
u
S)aT
Whether 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"<00>
is_prerelease
szVersion.is_prereleasec

C
<01>
|jd
u
S)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"<00>is_postrelease<73>
<00>
	zVersion.is_postreleasec

C
rn)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"<00>
is_devrelease<73>
rpzVersion.is_devreleasec

C
st|j
<01>
d
kr|j
dSdS)zqThe first item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").major
        1
        r	r
<00><02>lenrr,r!r!r"<00>major<6F>
sz
Version.majorc

C
<01>t|j
<01>
d
kr|j
dSdS)z<>The second item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").minor
        2
        >>> Version("1").minor
        0
        <20>r	r
rrr,r!r!r"<00>minor<6F>
<00>	z
Version.minorc

C
ru)z<>The third item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").micro
        3
        >>> Version("1").micro
        0
        <20>rvr
rrr,r!r!r"<00>micro<72>
rxz
Version.microN)r#r$r%r?)r%r$r=)r%r)r%r)r%rg)r%rj)r%r0)rrrr'<00>re<72>compiler<00>VERBOSE<53>
IGNORECASErOr rYrZre<00>propertyrrrrrrrkrlrmrorqrtrwrzr!r!r!r"r<00>sF




&
!




















<01>letterrj<00>number<65> str | bytes | SupportsInt | NonercC
sv|r-|
durd
}
|<00><00>}|dkrd}n|dkrd}n
|dvr!d}n|dvr'd	}|t
|
<01>
fS|s9|
r9d	}|t
|
<01>
fSdS)
Nr
<00>alpha<68>
a<>beta<74>
b)<03>
cr<00>preview<65>rc)<02>rev<65>
rr)<02>lowerr)r<>r<>r!r!r"rT<00>
s"








rTz[\._-]rrc

C
s$|d
u
rtdd<03>t
<01>|<00>
D<00>
<01>
Sd
S)zR
    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
    Nc
s
s(<00>|]}
|
<01><00>s|
<01>
<01>nt|
<01>
V
qdSr*)<03>isdigitr<74>r)rC<00>partr!r!r"rE<00>
s
<02><16>
<EFBFBD>z'_parse_local_version.<locals>.<genexpr>)rR<00>_local_version_separatorsrS)
rr!r!r"rU<00>
s

<08>rUrrrrrrrr>cC
s<>tt
tt<03>d
d<02>t
|
<01>
<01><02>
<01>
<01>
}|dur|dur|du
rt}n	|dur&t}n|}|dur/t}n|}|dur8t}	n|}	|durAt}
n	tdd<04>|D<00>
<01>
}
|||||	|
fS)Nc

S
s|d
kS)Nr
r!)
r^r!r!r"<00><lambda>sz_cmpkey.<locals>.<lambda>c
s
s*<00>|]}
t|
t
<01>r
|
dfnt|
fV
qd
S)r_N)r2rrrBr!r!r"rE/s<02>

<EFBFBD>z_cmpkey.<locals>.<genexpr>)rR<00>reversed<65>list<73>	itertools<6C>	dropwhilerr
)rrrrrr<00>_release<73>_pre<72>_post<73>_dev<65>_localr!r!r"rW<00>
s(

<04>



	
<08>rW)r#r$r%r)r<>rjr<>r<>r%r)rrjr%r)rrrrrrrrrrrrr%r>)'r'<00>
__future__rr<>r{<00>typingrrrrrr<00>_structuresr
rrr
<00>__all__rr$<00>	LocalType<70>CmpPrePostDevType<70>CmpLocalTyper>r0<00>VersionComparisonMethodrr<00>
ValueErrorrr(<00>_VERSION_PATTERNrrrTr|r<>rUrWr!r!r!r"<00><module>
sL
 


*
<02><04>






<02><04>
	
0

'
#