intellecton/venv/lib/python3.12/site-packages/packaging/__pycache__/version.cpython-312.pyc

Ë
KÀjá•ã
ód—dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlmZmZmZm	Z	m
Z
mZmZm
Z

ejrd
dlmZmZ
ej$dk\rd
dlmZ
nejrd
dlmZ
nd
dlZd
dlZd<d„Zd	d
dddddd
œZgd¢
Zd=d„Zee
eefdfZeeeefdfZeeeeeeefZe
eeeedfefeeeedfeeffZeeege fZ!Gd„ded¬«Z"d>d„Z#d?d„Z$Gd„de%«Z&Gd„d«Z'dZ(e(jSdd«jSdd «Z*ejVjXd!k(rej$d"ks7ejVjXd#k(rej$d$ksej$d%kre*n
e(Z-	ej\d&ej^ej`z«Z1e2d'«
Z3d@d(„Z4dAd)„Z5dBd*„Z6dCd+„Z7dDd,„Z8dEd-„Z9Gd.„d/e	«Z:Gd0„de'«Z;Gd1„d2e;«Z<						dFd3„Z=ej\d4«
Z>dGd5„Z?d
d6d7d8œZ@d9ZAd:ZBd9ZCeBd
d
d
d6d
fZD														dHd;„ZEy)IzZ
.. testsetup::

    from packaging.version import parse, normalize_pre, Version, _cmpkey
é)
ÚannotationsN)ÚAnyÚCallableÚLiteralÚ
NamedTupleÚSupportsIntÚTupleÚ	TypedDictÚUnion)ÚSelfÚUnpack)éé
)
Ú
deprecatedc

ó‡—dˆf
d
„}
|
S)Nc

óH•
‡—t
j‰«
dˆˆfd
„«}
|
S)Nc
óL•—t
j‰td
¬«
‰|i|
¤
Ž
S)Né)ÚcategoryÚ
stacklevel)ÚwarningsÚwarnÚDeprecationWarning)ÚargsÚkwargsÚfuncÚmessages  €€úT/home/antigravity/intellecton/venv/lib/python3.12/site-packages/packaging/version.pyÚwrapperz/_deprecated.<locals>.decorator.<locals>.wrapper's*ø€ä—
‘
ØÜ/Ø õñ
˜TÐ, VÑ,Ð,ó)rÚobjectrr!Úreturnr!)Ú	functoolsÚwraps)rrrs` €rÚ	decoratorz_deprecated.<locals>.decorator&s%ù€Ü
�_‰_˜TÓ
"õ
-ó#ð
-ðˆNr )rzCallable[[...], object]r"r!©)rr%s` rÚ_deprecatedr'%sø€õ
	ðÐr Ú
aÚ
bÚrcÚpost)ÚalphaÚbetaÚ
cÚpreÚpreviewÚrevÚ
r)ÚVERSION_PATTERNÚInvalidVersionÚVersionÚ
normalize_preÚparsec

ó—tS©
N)
Ú__all__r&r rÚ__dir__r;Bs€Ü€Nr .c
óJ—eZ
dZUd
ed<ded<ded<d
ed<d
ed<d	ed
<y)Ú_VersionReplaceú
int | NoneÚepochztuple[int, ...] | NoneÚreleaseútuple[str, int] | Noner/r+Údevú
str | NoneÚlocalN©Ú__name__Ú
__module__Ú__qualname__Ú__annotations__r&r rr=r=Qs%…ØÓØ
#Ó#Ø	ÓØ
ÓØ	ƒOØÔr r=F)
Útotalc


óN—|j
«}tj||«S)
a8
Normalize the pre-release segment of a version string.

    Returns a lowercase version of the string if not a known pre-release
    identifier.

    >>> normalize_pre('alpha')
    'a'
    >>> normalize_pre('BETA')
    'b'
    >>> normalize_pre('rc')
    'rc'

    :param letter:

    .. versionadded:: 26.1
    )ÚlowerÚ_LETTER_NORMALIZATIONÚget)
Úletters
 rr6r6Zs"€ð"�\‰\‹^€FÜ ×$Ñ$ V¨VÓ4Ð4r r5c

ó—t
|«
S)
a
Parse the given version string.

    This is identical to the :class:`Version` constructor.

    >>> 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.
    )
r5)
Úversions
 rr7r7os€ô�7ÓÐr c

ó—eZ
dZd
Zy)r4zÉRaised when a version string is not a valid version.

    >>> Version("invalid")
    Traceback (most recent call last):
        ...
    packaging.version.InvalidVersion: Invalid version: 'invalid'
    N)rFrGrHÚ__doc__r&r rr4r4}s„òr r4c
ór—eZ
dZd
Zej
r	edd„«Zdd„Zd
d„Z	d
d„Z
dd„Zd
d„Zd
d„Z
dd	„Zy
)Ú_BaseVersionr&c

ó—yr9r&©
Úselfs
 rÚ_keyz_BaseVersion._key�s€Ø+.r c

ó,—t
|j«
Sr9)ÚhashrYrWs
 rÚ__hash__z_BaseVersion.__hash__’s€Ü�D—I‘I‹Ðr c
ó`—t
|
t«stS|j|
jkSr9©Ú
isinstancerUÚNotImplementedrY©rXÚothers  rÚ__lt__z_BaseVersion.__lt__˜ó%€Ü˜%¤Ô.Ü!Ð!à�y‰y˜5Ÿ:™:Ñ%Ð%r c
ó`—t
|
t«stS|j|
jkSr9r^ras  rÚ__le__z_BaseVersion.__le__žó%€Ü˜%¤Ô.Ü!Ð!à�y‰y˜EŸJ™JÑ&Ð&r c
ó`—t
|
t«stS|j|
jk(Sr9r^ras  rÚ__eq__z_BaseVersion.__eq__¤rgr c
ó`—t
|
t«stS|j|
jk\Sr9r^ras  rÚ__ge__z_BaseVersion.__ge__ªrgr c
ó`—t
|
t«stS|j|
jkDSr9r^ras  rÚ__gt__z_BaseVersion.__gt__°rdr c
ó`—t
|
t«stS|j|
jk7Sr9r^ras  rÚ__ne__z_BaseVersion.__ne__¶rgr N)r"ztuple[Any, ...]©r"Úint©rbrUr"Úbool©rbr!r"rs)rFrGrHÚ	__slots__ÚtypingÚ
TYPE_CHECKINGÚpropertyrYr\rcrfrirkrmror&r rrUrU‡sC„Ø€Ið
×Òà	Ú.ó
Ø.ó
ó&ó'ó'ó'ó&ô'r rUa3
    v?+                                                   # optional leading v
    (?a:
        (?:(?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]+)?
        )?+
    )
    (?a:\+
        (?P<local>                                        # local version
            [a-z0-9]+
            (?:[._-][a-z0-9]+)*+
        )
    )?+
z*+Ú
*z?+ú
?Úcpython)rééÚpypy)rr|r)rr|z[a-z0-9]+(?:[._-][a-z0-9]+)*z.0123456789c


ó\—|x
s
d
}
t
|
t«r|
d
k\r|
Sd|
›�}t|«
‚
)Nrz(epoch must be non-negative integer, got ©r_rqr4)Úvaluer?Úmsgs   rÚ_validate_epochrƒ

s7€ØŠJ�Q€EÜ�%œÔ %¨1¢*؈Ø4°U°GÐ
<€CÜ
˜Ó
Ðr c


ó’—|€d
n
|}
t
|
t«r"t|
«
dkDrtd„|
D««
r|
Sd|
›�}t	|«
‚
)N)
rrc
3
óJK
—|]}
t
|
t«x
r
|
dk\–
—

Œy
­w
)rN)r_rq)Ú.0Ú
is  rú	<genexpr>z$_validate_release.<locals>.<genexpr>
s#èø€Ò?°!”
˜1œcÓ"Ò- q¨A¡vÓ-Ñ?ùs‚!#
z@release must be a non-empty tuple of non-negative integers, got )r_ÚtupleÚlenÚallr4)r�r@r‚s   rÚ_validate_releaserŒ
sM€Ø�m‰d¨€Gä�7œEÔ"Ü�‹L˜1ÒÜÑ?°wÔ?Ô?àˆØLÈWÈIÐ
V€CÜ
˜Ó
Ðr c


óÀ—|€|St
|t«r;t|«
d
k(r-|\}
}t|
«
}
|
dvrt
|t«r	|dk\r|
|fSd|›�}t|«
‚
)Nr>r(r)r*rz=pre must be a tuple of ('a'|'b'|'rc', non-negative int), got )r_r‰rŠr6rqr4)r�rOÚnumberr‚s    rÚ
_validate_prer�
sn€Ø€}؈Ü�%œÔ¤C¨£J°!¢O؉ˆ�ܘvÓ&ˆØÐ%Ñ%¬*°V¼SÔ*AÀfÐPQÂkà˜FÐ#Ð#ØIÈ%ÈÐ
Q€CÜ
˜Ó
Ðr c


ó\—|€|St
|t«r	|d
k\rd|fSd|›�}
t|
«
‚
)Nrr+z'post must be non-negative integer, got r€©r�r‚s  rÚ_validate_postr’+
s=€Ø€}؈Ü�%œÔ %¨1¢*ؘˆÐØ3°E°7Ð
;€CÜ
˜Ó
Ðr c


ó\—|€|St
|t«r	|d
k\rd|fSd|›�}
t|
«
‚
)NrrBz&dev must be non-negative integer, got r€r‘s  rÚ
_validate_devr”4
s=€Ø€}؈Ü�%œÔ %¨1¢*Ø�uˆ~ÐØ2°5°'Ð
:€CÜ
˜Ó
Ðr c


óŠ—|€|St
|t«r tj|«
rt	|«
Sd
|›�}
t|
«
‚
)Nz*local must be a valid version string, got )r_ÚstrÚ_LOCAL_PATTERNÚ	fullmatchÚ_parse_local_versionr4r‘s  rÚ_validate_localrš=
sE€Ø€}؈Ü�%œÔ¤.×":Ñ":¸5Ô"AÜ# EÓ*Ð*Ø6°u°iÐ
@€CÜ
˜Ó
Ðr c
óJ—eZ
dZUd
ed<ded<ded<ded<d	ed
<ded<y
)Ú_Versionrqr?útuple[int, ...]r@ú!tuple[Literal['dev'], int] | NonerBú*tuple[Literal['a', 'b', 'rc'], int] | Noner/ú"tuple[Literal['post'], int] | Noner+úLocalType | NonerDNrEr&r rrœrœG
s%…؃JØ
ÓØ	*Ó*Ø	3Ó3Ø
,Ó,ØÔr rœc
ó‡—eZ
dZUd
ZdZdZ	ejdezdzejejz«Zded<ded<d	ed
<ded<d
ed<ded<ded<ded<d9d„Z
eddddddœ													d:d„«Zd;d„Zed<d„«Zd=d„Zd>ˆf
d„Zd>ˆf
d„Zd?ˆf
d„Zd>ˆf
d „Zd>ˆf
d!„Zd?ˆf
d"„Z		d@d#„ZdAd$„Zeed%«
dBd&„««Zej<ed%«
dCd'„««ZdDd(„ZdDd)„Z edDd*„«Z!ed=d+„«Z"edEd,„«Z#edFd-„«Z$edGd.„«Z%edGd/„«Z&edHd0„«Z'edDd1„«Z(edDd2„«Z)edId3„«Z*edId4„«Z+edId5„«Z,ed=d6„«Z-ed=d7„«Z.ed=d8„«Z/ˆx
Z0S)Jr5aÄ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

    :class:`Version` is immutable; use :meth:`__replace__` to change
    part of a version.

    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.
    )Ú_devÚ_epochÚ_hash_cacheÚ
_key_cacheÚ_localÚ_postÚ_preÚ_release)
Ú_strz\s*rqr¤r�rªržr£rŸr©r r¨r¡r§r>r¥z
CmpKey | Noner¦c
ó—tj|
«
r`	ttt|
jd
«
««
|_d|_	d|_
d|_d|_d|_
d|_d|_y|j j#|
«
}|std|
›�«
‚
|j%d«
rt	|j%d«
«
n
d|_	ttt|j%d«
jd
«
««
|_t'|j%d«
|j%d	«
«|_
t'|j%d
«
|j%d«
x
s
|j%d«
«|_t'|j%d
«
|j%d«
«|_t)|j%d«
«
|_
d|_d|_y#t$r$
d|
jd
«
vrtd|
›�«
d‚‚wxYw
)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: Nrr?r@Úpre_lÚpre_nÚpost_lÚpost_n1Úpost_n2Údev_lÚdev_nrD)Ú_SIMPLE_VERSION_INDICATORSÚ
issupersetr‰ÚmaprqÚsplitrªÚ
ValueErrorr4r¤r©r¨r£r§r¦r¥Ú_regexr˜ÚgroupÚ_parse_letter_versionr™)rXrQÚmatchs   rÚ__init__zVersion.__init__”
s·
€ô&×0Ñ0°Ô9ð	
Ü %¤c¬#¨w¯}©}¸SÓ/AÓ&BÓ C�”
ðˆDŒK؈DŒI؈DŒJ؈DŒI؈DŒKØ"ˆDŒOØ#ˆDÔØð—‘×%Ñ% gÓ.ˆÙÜ Ð#4°W°KÐ!@ÓAÐAØ38·;±;¸wÔ3G”c˜%Ÿ+™+ gÓ.Ô/ÈQˆŒÜœc¤# u§{¡{°9Ó'=×'CÑ'CÀCÓ'HÓIÓJˆŒ
ô*¨%¯+©+°gÓ*>ÀÇÁÈGÓ@TÓUˆŒ	Ü*Ø�K‰K˜Ó! 5§;¡;¨yÓ#9Ò#S¸U¿[¹[ÈÓ=Só
ˆŒ
ô*¨%¯+©+°gÓ*>ÀÇÁÈGÓ@TÓUˆŒ	Ü*¨5¯;©;°wÓ+?Ó@ˆŒðˆŒØˆÕøôG
ò
𘟙 sÓ+Ñ+Ü(Ð+<¸W¸KÐ)HÓIÈtÐSàð
ús—-GÇ-H
rN)r?r/r+rBrDc

ó<
—t
|
«
}t|«
}|�t|«
n
d
}	|�t|«
n
d
}
|�t	|«
n
d
}|�t|«
n
d
}|j
|«
}
d
|
_d
|
_||
_	||
_
|	|
_|
|
_||
_
||
_|
S)a(
        Return a new version composed of the various parts.

        This allows you to build a version without going though a string and
        running a regular expression. It normalizes pre-release strings. The
        ``release=`` keyword argument is required.

        >>> Version.from_parts(release=(1,2,3))
        <Version('1.2.3')>
        >>> Version.from_parts(release=(0,1,0), pre=("b", 1))
        <Version('0.1.0b1')>

        :param epoch:
        :param release: This version tuple is required

        .. versionadded:: 26.1
        N)rƒrŒr�r’r”ršÚ__new__r¦r¥r¤rªr©r¨r£r§)Úclsr?r@r/r+rBrDr¤rªr©r¨r£r§Únew_versions              rÚ
from_partszVersion.from_partsÆ
s®€ô8! Ó'ˆÜ$ WÓ-ˆØ%( _Œ}˜SÔ!¸$ˆØ(,Ð(8”˜tÔ$¸dˆØ%( _Œ}˜SÔ!¸$ˆØ+0Ð+<” Ô'À$ˆà—k‘k #Ó&ˆØ!%ˆÔØ"&ˆÔØ#ˆÔØ'ˆÔ؈ÔØ!ˆÔ؈ÔØ#ˆÔàÐr c

óà—d
|
vrt
|
d
«
n|j}d|
vrt|
d«
n|j}d|
vrt	|
d«
n|j
}d|
vrt
|
d«
n|j}d|
vrt|
d«
n|j}d|
vrt|
d«
n|j}||jk(rM||jk(r>||j
k(r/||jk(r ||jk(r||jk(r|S|jj|j«
}d|_d|_||_
||_||_||_||_	||_|S)aß
        __replace__(*, epoch=..., release=..., pre=..., post=..., dev=..., local=...)

        Return a new version with parts replaced.

        This returns a new version (unless no parts were changed). The
        pre-release is normalized. Setting a value to ``None`` clears it.

        >>> v = Version("1.2.3")
        >>> v.__replace__(pre=("a", 1))
        <Version('1.2.3a1')>

        :param int | None epoch:
        :param tuple[int, ...] | None release:
        :param tuple[str, int] | None pre:
        :param int | None post:
        :param int | None dev:
        :param str | None local:

        .. versionadded:: 26.0
        .. versionchanged:: 26.1

           The pre-release portion is now normalized.
        r?r@r/r+rBrDN)rƒr¤rŒrªr�r©r’r¨r”r£ršr§Ú	__class__rÁr¦r¥)	rXrr?r@r/r+rBrDrÃs	         rÚ__replace__zVersion.__replace__õ
s]
€ð25<¸vÑ4E”  w¡Ô0È4Ï;É;ˆð˜FÑ"ô
˜f YÑ/Ô0à—‘ð	ð
/4°v©oŒm˜F 5™MÔ*À4Ç9Á9ˆØ17¸6Ñ1AŒ~˜f V™nÔ-ÀtÇzÁzˆØ.3°v©oŒm˜F 5™MÔ*À4Ç9Á9ˆØ4;¸vÑ4E”  w¡Ô0È4Ï;É;ˆð
�T—[‘[Ò ؘ4Ÿ=™=Ò(Ø�t—y‘yÒ Ø˜Ÿ
™
Ò"Ø�t—y‘yÒ Ø˜Ÿ™Ò$àˆKà—n‘n×,Ñ,¨T¯^©^Ó<ˆØ!%ˆÔØ"&ˆÔØ"ˆÔØ&ˆÔ؈ÔØ ˆÔ؈ÔØ"ˆÔàÐr c

óÔ—|j€Qt|j|j|j|j
|j|j«|_|jSr9)r¦Ú_cmpkeyr¤rªr©r¨r£r§rWs
 rrYzVersion._key/sN€à�?‰?Ð"Ü%Ø—‘Ø—
‘
Ø—	‘	Ø—
‘
Ø—	‘	Ø—‘ó
ˆDŒOð�‰Ðr c

ó
—|jx
}
�|
S|jx
}€St|j|j|j
|j|j|j«x
|_
}t|«
x
|_}
|
Sr9)
r¥r¦rÉr¤rªr©r¨r£r§r[)rXÚcached_hashÚkeys   rr\zVersion.__hash__>s~€Ø×+Ñ+Ð+ˆKÐ8ØÐà—?‘?Ð"ˆCÐ+Ü$+Ø—‘Ø—
‘
Ø—	‘	Ø—
‘
Ø—	‘	Ø—‘ó
%ð
ˆDŒO˜cô*.¨c«Ð2ˆÔ˜;ØÐr c
ó•
—t
|
t«rÓ|j€Qt|j|j
|j|j|j|j«|_|
j€Qt|
j|
j
|
j|
j|
j|
j«|
_|j|
jkSt
|
t«stSt‰|�5|
«
Sr9)r_r5r¦rÉr¤rªr©r¨r£r§rUr`Úsuperrc©rXrbrÆs  €rrczVersion.__lt__PóÈø€Ü�eœWÔ%Ø�‰Ð&Ü")Ø—K‘KØ—M‘MØ—I‘IØ—J‘JØ—I‘IØ—K‘Kó
#�”ð×ÑÐ'Ü#*Ø—L‘LØ—N‘NØ—J‘JØ—K‘KØ—J‘JØ—L‘Ló
$�Ô ð—?‘? U×%5Ñ%5Ñ5Ð5ä˜%¤Ô.Ü!Ð!ä‰w‰~˜eÓ$Ð$r c
ó•
—t
|
t«rÓ|j€Qt|j|j
|j|j|j|j«|_|
j€Qt|
j|
j
|
j|
j|
j|
j«|
_|j|
jkSt
|
t«stSt‰|�5|
«
Sr9)r_r5r¦rÉr¤rªr©r¨r£r§rUr`rÎrfrÏs  €rrfzVersion.__le__kóÈø€Ü�eœWÔ%Ø�‰Ð&Ü")Ø—K‘KØ—M‘MØ—I‘IØ—J‘JØ—I‘IØ—K‘Kó
#�”ð×ÑÐ'Ü#*Ø—L‘LØ—N‘NØ—J‘JØ—K‘KØ—J‘JØ—L‘Ló
$�Ô ð—?‘? e×&6Ñ&6Ñ6Ð6ä˜%¤Ô.Ü!Ð!ä‰w‰~˜eÓ$Ð$r c
ó•
—t
|
t«rÓ|j€Qt|j|j
|j|j|j|j«|_|
j€Qt|
j|
j
|
j|
j|
j|
j«|
_|j|
jk(St
|
t«stSt‰|�5|
«
Sr9)r_r5r¦rÉr¤rªr©r¨r£r§rUr`rÎrirÏs  €rrizVersion.__eq__†rÒr c
ó•
—t
|
t«rÓ|j€Qt|j|j
|j|j|j|j«|_|
j€Qt|
j|
j
|
j|
j|
j|
j«|
_|j|
jk\St
|
t«stSt‰|�5|
«
Sr9)r_r5r¦rÉr¤rªr©r¨r£r§rUr`rÎrkrÏs  €rrkzVersion.__ge__¡rÒr c
ó•
—t
|
t«rÓ|j€Qt|j|j
|j|j|j|j«|_|
j€Qt|
j|
j
|
j|
j|
j|
j«|
_|j|
jkDSt
|
t«stSt‰|�5|
«
Sr9)r_r5r¦rÉr¤rªr©r¨r£r§rUr`rÎrmrÏs  €rrmzVersion.__gt__¼rÐr c
ó•
—t
|
t«rÓ|j€Qt|j|j
|j|j|j|j«|_|
j€Qt|
j|
j
|
j|
j|
j|
j«|
_|j|
jk7St
|
t«stSt‰|�5|
«
Sr9)r_r5r¦rÉr¤rªr©r¨r£r§rUr`rÎrorÏs  €rrozVersion.__ne__×rÒr c

óŠ—|j|j|j|j|j|j
fSr9)r¤rªr©r¨r£r§rWs
 rÚ__getstate__zVersion.__getstate__òs8€ð
�K‰KØ�M‰MØ�I‰IØ�J‰JØ�I‰IØ�K‰Kð

ð	
r c
óú—d|_d|_
t|
t«rÆt	|
«
d
k(r(|
\|_|_|_|_|_	|_
yt	|
«
dk(r‚|
\}}t|t«rm|d|_|d|_|jd«
|_|jd«
|_|jd«
|_	|jd«
|_
yt|
t«rz|
jd	«
}|�g|j|_|j|_|j|_|j |_|j"|_	|j$|_
yt'd
|
›�«
‚
)Nérr¤rªr©r¨r£r§Ú_versionzCannot restore Version from )r¦r¥r_r‰rŠr¤rªr©r¨r£r§ÚdictrNr?r@r/r+rBrDÚ	TypeError)rXÚstateÚ
_Ú	slot_dictÚ
version_nts     rÚ__setstate__zVersion.__setstate__sJ
€ðˆŒØˆÔä�eœUÔ#Ü�5‹z˜QŠðñØ”KØ”MØ”IØ”JØ”IØ”KàÜ�5‹z˜QŠà$‘�
�9ܘi¬Ô.Ø"+¨HÑ"5�D”KØ$-¨jÑ$9�D”MØ )§
¡
¨fÓ 5�D”IØ!*§¡¨wÓ!7�D”JØ )§
¡
¨fÓ 5�D”IØ"+§-¡-°Ó"9�D”KØÜ�eœTÔ"🙠:Ó.ˆJØÐ%Ø(×.Ñ.�”Ø *× 2Ñ 2�”
Ø&ŸN™N�”	Ø'Ÿ_™_�”
Ø&ŸN™N�”	Ø(×.Ñ.�”ØäÐ6°u°iÐ@ÓAÐAr z4Version._version is private and will be removed soonc

óš—t
|j|j|j|j|j
|j«Sr9)rœr¤rªr£r©r¨r§rWs
 rrÛzVersion._version5s6€ôØ�K‰K˜Ÿ™¨¯	©	°4·9±9¸d¿j¹jÈ$Ï+É+ó
ð	
r c
óì—|
j|_
|
j|_|
j|_|
j|_|
j|_	|
j|_d|_d|_
yr9)r?r¤r@rªrBr£r/r©r+r¨rDr§r¦r¥)rXr�s  rrÛzVersion._version<sU€ð—k‘kˆŒØŸ
™
ˆŒ
Ø—I‘IˆŒ	Ø—I‘IˆŒ	Ø—Z‘ZˆŒ
Ø—k‘kˆŒØˆŒØˆÕr c

óN—d
|jj›dt|«
›d�S)z€A representation of the Version that shows all internal state.

        >>> Version('1.0.0')
        <Version('1.0.0')>
        ú
<ú
(z)>)rÆrFr–rWs
 rÚ__repr__zVersion.__repr__Hs(€ð�4—>‘>×*Ñ*Ð+¨1¬S°«Y¨M¸Ð<Ð<r c

ó¶
—d
j
tt|j««
}
|jr|j›d|
›�}
|j
�,|
dj
tt|j
««
z
}
|j�|
d|j›�z
}
|j�|
d|j›�z
}
|j�|
d|j›�z
}
|
S)z}A string representation of the version that can be round-tripped.

        >>> str(Version("1.0a5"))
        '1.0a5'
        r­ú
!r®z.postz.devú
+)	Újoinr¸r–r@r?r/r+rBrD)rXrQs  rÚ__str__zVersion.__str__PsÌ€ð—(‘(œ3œs D§L¡LÓ1Ó2ˆð�:Š:ØŸ™˜ A g YÐ/ˆGð�8‰8ÐØ�r—w‘wœs¤3¨¯©Ó1Ó2Ñ2ˆGð�9‰9Ð Ø˜˜tŸy™y˜kÐ*Ñ*ˆGð�8‰8ÐØ˜˜dŸh™h˜ZÐ(Ñ(ˆGð�:‰:Ð!Ø˜˜4Ÿ:™:˜,Ð'Ñ'ˆGàˆr c

ó—t
|«
S)
z Internal property for match_args©
r–rWs
 rr«zVersion._stros€ô�4‹yÐr c


ó—|jS)
zThe epoch of the version.

        >>> Version("2.0.0").epoch
        0
        >>> Version("1!2.0.0").epoch
        1
        )
r¤rWs
 rr?z
Version.epochts€ð�{‰{Ðr c


ó—|jS)
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.
        )
rªrWs
 rr@zVersion.releases€ð�}‰}Ðr c


ó—|jS)
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)
        )
r©rWs
 rr/zVersion.pre�s€ð�y‰yÐr c

ó<—|jr|jd
SdS)z™The post-release number of the version.

        >>> print(Version("1.2.3").post)
        None
        >>> Version("1.2.3.post1").post
        1
        é
N)
r¨rWs
 rr+zVersion.postžs€ð!%§
¢
ˆt�z‰z˜!‰}Ð4°Ð4r c

ó<—|jr|jd
SdS)z•The development number of the version.

        >>> print(Version("1.2.3").dev)
        None
        >>> Version("1.2.3.dev1").dev
        1
        rôN)
r£rWs
 rrBzVersion.dev©s€ð $Ÿyšyˆt�y‰y˜‰|Ð2¨dÐ2r c

ó`—|jr"d
jd„|jD««
Sy)zŸThe local version segment of the version.

        >>> print(Version("1.2.3").local)
        None
        >>> Version("1.2.3+abc").local
        'abc'
        r­c
3
ó2K
—|]}
t
|
«
–
—

Œy­w
r9rï)r†Ú
xs  rrˆz Version.local.<locals>.<genexpr>¾sèø€Ò8 qœC 
ŸFÑ8ùs‚
N)r§rìrWs
 rrDz
Version.local´s'€ð�;Š;Ø—8‘8Ñ8¨D¯K©KÔ8Ó8Ð8àr c

ó>—t
|«
jd
d«dS)aq
The public portion of the version.

        This returns a string. If you want a :class:`Version` again and care
        about performance, use ``v.__replace__(local=None)`` instead.

        >>> Version("1.2.3").public
        '1.2.3'
        >>> Version("1.2.3+abc").public
        '1.2.3'
        >>> Version("1!1.2.3dev1+abc").public
        '1!1.2.3.dev1'
        rërôr)r–r¹rWs
 rÚpubliczVersion.publicÂs€ô�4‹y�‰˜s AÓ& qÑ)Ð)r c

ó’—d
j
tt|j««
}
|jr|j›d|
›�S|
S)aThe "base version" of the version.

        This returns a string. If you want a :class:`Version` again and care
        about performance, use
        ``v.__replace__(pre=None, post=None, dev=None, local=None)`` instead.

        >>> Version("1.2.3").base_version
        '1.2.3'
        >>> Version("1.2.3+abc").base_version
        '1.2.3'
        >>> Version("1!1.2.3dev1+abc").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ê)rìr¸r–r@r?)rXÚrelease_segments  rÚbase_versionzVersion.base_versionÒs>€ð$Ÿ(™(¤3¤s¨D¯L©LÓ#9Ó:ˆØ48·J²J�$—*‘*�˜Q˜Ð/Ð0ÐSÀOÐSr c

ó>—|jd
u
x
s
|jd
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)rBr/rWs
 rÚ
is_prereleasezVersion.is_prereleaseçs!€ð�x‰x˜tÐ#Ò; t§x¡x°tÐ';Ð;r c

ó—|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)
r+rWs
 rÚis_postreleasezVersion.is_postreleaseøs€ð�y‰y Ð$Ð$r c

ó—|jd
u
S)z®Whether this version is a development release.

        >>> Version("1.2.3").is_devrelease
        False
        >>> Version("1.2.3.dev1").is_devrelease
        True
        N)
rBrWs
 rÚ
is_devreleasezVersion.is_devreleases€ð�x‰x˜tÐ#Ð#r c

óT—t
|j«
d
k\r|jdSdS)zqThe first item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").major
        1
        rôr©rŠr@rWs
 rÚmajorz
Version.majors'€ô#& d§l¡lÓ"3°qÒ"8ˆt�|‰|˜A‰Ð?¸aÐ?r c

óT—t
|j«
d
k\r|jdSdS)z›The second item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").minor
        2
        >>> Version("1").minor
        0
        rrôrr
rWs
 rÚminorz
Version.minoró'€ô#& d§l¡lÓ"3°qÒ"8ˆt�|‰|˜A‰Ð?¸aÐ?r c

óT—t
|j«
d
k\r|jdSdS)zšThe third item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").micro
        3
        >>> Version("1").micro
        0
        rrrr
rWs
 rÚmicroz
Version.micro"r	
r )rQr–r"ÚNone)r?rqr@r�r/rAr+r>rBr>rDrCr"r)rzUnpack[_VersionReplace]r"r)r"ÚCmpKeyrprrrt)r"zutuple[int, tuple[int, ...], tuple[str, int] | None, tuple[str, int] | None, tuple[str, int] | None, LocalType | None])rÞr!r"r
)r"rœ)r�rœr"r
)r"r–©r"r�)r"rŸ)r"r>)r"rC)r"rs)1rFrGrHrSruÚ__match_args__ÚreÚcompiler3ÚVERBOSEÚ
IGNORECASEr»rIr¿ÚclassmethodrÄrÇrxrYr\rcrfrirkrmrorØrâr'rÛÚsetterrèrír«r?r@r/r+rBrDrúrýrÿr

r
r
r
r
Ú
__classcell__©
rÆs
@rr5r5P
sÃø…ñ"ðH
	€Ið€NððˆR�Z‰Z˜ Ñ0°6Ñ9¸2¿:¹:ÈÏ
É
Ñ;UÓ
V€FàƒKØÓØ
+Ó+Ø
4Ó4Ø-Ó-ØÓàÓØÓó0 ðd
ðà&*ØØØ ñ,ðð,ð!ð	,ð
$ð,ðð
,ðð,ðð,ð