mrhavens/intellecton
1
0
Fork 0
mirror of http://forgejo.openclaw.svc.cluster.local:3000/mrhavens/intellecton.git synced 2026-06-18 01:22:57 +00:00
Code Issues Projects Packages Wiki Activity
intellecton/venv/lib/python3.12/site-packages/packaging/__pycache__/specifiers.cpython-312.pyc

702 lines
74 KiB
Text
Raw Normal View History

Add core physics manuscript: The Computability of Recursive Coherence
2026-05-31 07:56:40 +00:00
<EFBFBD>
K<>jZ<00><01><><00>UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m
Z
m Z m Z m Z mZmZmZmZmZddlmZddlmZmZej0dk\rdd l mZne
rdd lmZgd
<EFBFBD>Zd:d <0B>Zd;d <0C>Zd<d <0A>Zed<0E>Zeee fZ!ede!<21><10>Z"e ee ge#fZ$ed<11>Z%de&d<d=d<14>Z'Gd<15>dejP<00>Z)ejTGd<17>d<18><00>Z+ejTGd<19>d<1A><00>Z,ejTGd<1B>d<1C><00>Z-e jreee+dfZ.e/e,e-fZ0e,dd<1D>Z1e-dd<1D>Z2e1e2ffZ3de&d<d>d <20>Z4 d?d!<21>Z5d@d"<22>Z6d@d#<23>Z7dAd$<24>Z8d@d%<25>Z9d@d&<26>Z:d@d'<27>Z; dBd(<28>Z<Gd)<29>d*e=<3D>Z>Gd+<2B>d,ej~<00>-<2D>Z@Gd.<2E>d/e@<40>ZAej<>d0<64>ZC dCd1<64>ZDdDd2<64>ZEdEd3<64>ZFdFd4<64>ZGdGd5<64>ZHdHd6<64>ZIdId7<64>ZJGd8<64>d9e@<40>ZKy)Jz<4A>
.. testsetup::
from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
from packaging.version import Version
<EFBFBD>)<01> annotationsN) <09> TYPE_CHECKING<4E>Any<6E>Callable<6C>Final<61>Iterable<6C>Iterator<6F>Sequence<63>TypeVar<61>Union<6F>)<01>canonicalize_version)<02>InvalidVersion<6F>Version)<02><00>
)<01> TypeGuard)<04> BaseSpecifier<65>InvalidSpecifier<65> Specifier<65> SpecifierSetc<01><00>tS<00>N)<01>__all__<5F><00><00>W/home/antigravity/intellecton/venv/lib/python3.12/site-packages/packaging/specifiers.py<70>__dir__r0s<00><00> <12>Nrc<01><><00>t|t<00>xr8t|<00>dk(xr(t|dt<00>xrt|dt<00>S)N<>rr )<04>
isinstance<EFBFBD>tuple<6C>len<65>str)<01>specs r<00>_validate_specr&4sI<00><00><12>4<EFBFBD><15><1F> %<25> <0F><04>I<EFBFBD><11>N<EFBFBD> %<25> <16>t<EFBFBD>A<EFBFBD>w<EFBFBD><03> $<24> %<25> <17>t<EFBFBD>A<EFBFBD>w<EFBFBD><03> $<24> rc<01>.<00>|duxst|t<00>Sr)r!<00>bool)<01>pres r<00> _validate_prer*=s<00><00> <0E>$<24>;<3B> /<2F>*<2A>S<EFBFBD>$<24>/<2F>/r<00>T<>UnparsedVersionVar)<01>boundz0.dev0zFinal[Version]<5D> _MIN_VERSIONc<01><><00>t|<00>}|dkDr!||dz
dk(r|dz}|dkDr ||dz
dk(r<01>|t|<00>k(r|S|d|S)zDStrip trailing zeros from a release tuple for normalized comparison.r rN)r#)<02>release<73>ends r<00> _trim_releaser2Js`<00><00>
<0A>g<EFBFBD>,<2C>C<EFBFBD>
<0A><01>'<27>g<EFBFBD>c<EFBFBD>A<EFBFBD>g<EFBFBD>&<26>!<21>+<2B> <0B>q<EFBFBD><08><03> <0E><01>'<27>g<EFBFBD>c<EFBFBD>A<EFBFBD>g<EFBFBD>&<26>!<21>+<2B><19>S<EFBFBD><17>\<5C>)<29>7<EFBFBD><<3C>w<EFBFBD>t<EFBFBD><03>}<7D><rc<01>T<00>eZdZdZej
<00>Zej
<00>Zy)<03> _BoundaryKindz5Where a boundary marker sits in the version ordering.N)<08>__name__<5F>
__module__<EFBFBD> __qualname__<5F>__doc__<5F>enum<75>auto<74> AFTER_LOCALS<4C> AFTER_POSTSrrrr4r4Rs<00><00>?<3F><1C>4<EFBFBD>9<EFBFBD>9<EFBFBD>;<3B>L<EFBFBD><1B>$<24>)<29>)<29>+<2B>Krr4c<01>D<00>eZdZdZdZd
d<03>Zd d<04>Zd d<05>Zd d<06>Zdd<07>Z dd<08>Z
y )<10>_BoundaryVersiona A point on the version line between two real PEP 440 versions.
Some specifier semantics imply boundaries between real versions:
``<=1.0`` includes ``1.0+local`` and ``>1.0`` excludes
``1.0.post0``. No real :class:`Version` falls on those boundaries,
so this class creates values that sort between the real versions
on either side.
Two kinds exist, shown relative to a base version V::
V < V+local < AFTER_LOCALS(V) < V.post0 < AFTER_POSTS(V)
``AFTER_LOCALS`` sits after V and every V+local, but before
V.post0. Upper bound of ``<=V``, ``==V``, ``!=V``.
``AFTER_POSTS`` sits after every V.postN, but before the next
release segment. Lower bound of ``>V`` (final or pre-release V)
to exclude post-releases per PEP 440.
)<03>_kind<6E>_trimmed_release<73>versionc<01>T<00>||_||_t|j<00>|_yr)rAr?r2r0r@)<03>selfrA<00>kinds r<00>__init__z_BoundaryVersion.__init__qs!<00><00><1E><04> <0C><19><04>
<EFBFBD> -<2D>g<EFBFBD>o<EFBFBD>o<EFBFBD> ><3E><04>rc<01><><00>|j}|j|jk(r;t|j<00>|jk(r|j
|j
k(sy|j tjk(r4|j|jk(xr|j|jk(S|j|jk(xs|jduS)z6Is ``other`` a version that this boundary sorts above?FN) rA<00>epochr2r0r@r)r?r4r;<00>post<73>dev)rC<00>other<65>vs r<00>
_is_familyz_BoundaryVersion._is_familyvs<><00><00> <10>L<EFBFBD>L<EFBFBD><01> <11>K<EFBFBD>K<EFBFBD>1<EFBFBD>7<EFBFBD>7<EFBFBD> "<22><1D>e<EFBFBD>m<EFBFBD>m<EFBFBD>,<2C><04>0E<30>0E<30>E<><15> <09> <09>Q<EFBFBD>U<EFBFBD>U<EFBFBD>"<22><18> <0F>:<3A>:<3A><1D>3<>3<> 3<><18>:<3A>:<3A><11><16><16>'<27>><3E>E<EFBFBD>I<EFBFBD>I<EFBFBD><11><15><15>,><3E> ><3E><14>y<EFBFBD>y<EFBFBD>A<EFBFBD>E<EFBFBD>E<EFBFBD>!<21>;<3B>U<EFBFBD>Z<EFBFBD>Z<EFBFBD>t<EFBFBD>%;<3B>;rc<01><><00>t|t<00>r4|j|jk(xr|j|jk(StSr)r!r>rAr?<00>NotImplemented<65>rCrJs r<00>__eq__z_BoundaryVersion.__eq__<5F>s8<00><00> <15>e<EFBFBD>-<2D> .<2E><17><<3C><<3C>5<EFBFBD>=<3D>=<3D>0<>N<>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>5<EFBFBD>;<3B>;<3B>5N<35> N<><1D>rc<01>&<00>t|t<00>r_|j|jk7r|j|jkS|jj|jjkS|j |<01> xr|j|kSr)r!r>rAr?<00>valuerLrOs r<00>__lt__z_BoundaryVersion.__lt__<5F>so<00><00> <15>e<EFBFBD>-<2D> .<2E><13>|<7C>|<7C>u<EFBFBD>}<7D>}<7D>,<2C><1B>|<7C>|<7C>e<EFBFBD>m<EFBFBD>m<EFBFBD>3<>3<><17>:<3A>:<3A>#<23>#<23>e<EFBFBD>k<EFBFBD>k<EFBFBD>&7<>&7<>7<> 7<><17>?<3F>?<3F>5<EFBFBD>)<29>)<29>B<>d<EFBFBD>l<EFBFBD>l<EFBFBD>U<EFBFBD>.B<>Brc<01>D<00>t|j|jf<02>Sr)<03>hashrAr?<00>rCs r<00>__hash__z_BoundaryVersion.__hash__<5F>s<00><00><13>T<EFBFBD>\<5C>\<5C>4<EFBFBD>:<3A>:<3A>.<2E>/<2F>/rc<01>|<00>|jj<00>d|j<00>d|jj<00>d<03>S)N<>(z, <20>))<05> __class__r5rAr?<00>namerVs r<00>__repr__z_BoundaryVersion.__repr__<5F>s4<00><00><16>.<2E>.<2E>)<29>)<29>*<2A>!<21>D<EFBFBD>L<EFBFBD>L<EFBFBD>+;<3B>2<EFBFBD>d<EFBFBD>j<EFBFBD>j<EFBFBD>o<EFBFBD>o<EFBFBD>=N<>a<EFBFBD>P<>PrN)rArrDr4<00>return<72>None)rJrr^r(<00>rJ<00>objectr^r()rJz_BoundaryVersion | Versionr^r(<00>r^<00>int<6E>r^r$) r5r6r7r8<00> __slots__rErLrPrSrWr]rrrr>r>Ys.<00><00><08>(9<>I<EFBFBD>?<3F>
<<3C><1E>
C<01>0<>Qrr>c<01><<00>eZdZdZdZd d<03>Zd
d<04>Zd d<05>Zd d<06>Zd d<07>Z y)<0E> _LowerBoundz<64>Lower bound of a version range.
A version *v* of ``None`` means unbounded below (-inf).
At equal versions, ``[v`` sorts before ``(v`` because an inclusive
bound starts earlier.
<20><02> inclusiverAc<01> <00>||_||_yr<00>rAri<00>rCrAris rrEz_LowerBound.__init__<5F><00><00><00><1E><04> <0C>"<22><04>rc<01><><00>t|t<00>stS|j|jk(xr|j|jk(Sr<00>r!rgrNrArirOs rrPz_LowerBound.__eq__<5F><00>7<00><00><19>%<25><1B>-<2D>!<21> !<21><13>|<7C>|<7C>u<EFBFBD>}<7D>}<7D>,<2C>R<><14><1E><1E>5<EFBFBD>?<3F>?<3F>1R<31>Rrc<01><00>t|t<00>stS|j<00>|jduS|j<00>y|j|jk7r|j|jkS|jxr |j S)NFrorOs rrSz_LowerBound.__lt__<5F>sq<00><00><19>%<25><1B>-<2D>!<21> !<21> <0F><<3C><<3C> <1F><18>=<3D>=<3D><04>,<2C> ,<2C> <10>=<3D>=<3D> <20><18> <0F><<3C><<3C>5<EFBFBD>=<3D>=<3D> (<28><17><<3C><<3C>%<25>-<2D>-<2D>/<2F> /<2F><13>~<7E>~<7E>5<>e<EFBFBD>o<EFBFBD>o<EFBFBD>"5<>5rc<01>D<00>t|j|jf<02>Sr<00>rUrArirVs rrWz_LowerBound.__hash__<5F><00><00><00><13>T<EFBFBD>\<5C>\<5C>4<EFBFBD>><3E>><3E>2<>3<>3rc<01>t<00>|jrdnd}d|jj<00>d|<01>|j<00>d<05>S)N<>[rY<00><<3C> <20>><3E>rir[r5rA<00>rC<00>brackets rr]z_LowerBound.__repr__<5F>s8<00><00><1D><1E><1E>#<23>S<EFBFBD><07><12>4<EFBFBD>><3E>><3E>*<2A>*<2A>+<2B>1<EFBFBD>W<EFBFBD>I<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>5E<35>Q<EFBFBD>G<>GrN<>rA<00>_VersionOrBoundaryrir(r^r_r`)rJrgr^r(rbrd<00>
r5r6r7r8rerErPrSrWr]rrrrgrg<00><00>)<00><00><08>)<29>I<EFBFBD>#<23>S<01>
6<>4<>Hrrgc<01><<00>eZdZdZdZd d<03>Zd
d<04>Zd d<05>Zd d<06>Zd d<07>Z y)<0E> _UpperBoundz<64>Upper bound of a version range.
A version *v* of ``None`` means unbounded above (+inf).
At equal versions, ``v)`` sorts before ``v]`` because an exclusive
bound ends earlier.
rhc<01> <00>||_||_yrrkrls rrEz_UpperBound.__init__<5F>rmrc<01><><00>t|t<00>stS|j|jk(xr|j|jk(Sr<00>r!r<>rNrArirOs rrPz_UpperBound.__eq__<5F>rprc<01><><00>t|t<00>stS|j<00>y|j<00>y|j|jk7r|j|jkS|j xr |jS<00>NFTr<54>rOs rrSz_UpperBound.__lt__<5F>se<00><00><19>%<25><1B>-<2D>!<21> !<21> <0F><<3C><<3C> <1F><18> <10>=<3D>=<3D> <20><17> <0F><<3C><<3C>5<EFBFBD>=<3D>=<3D> (<28><17><<3C><<3C>%<25>-<2D>-<2D>/<2F> /<2F><17>><3E>><3E>!<21>5<>e<EFBFBD>o<EFBFBD>o<EFBFBD>5rc<01>D<00>t|j|jf<02>SrrsrVs rrWz_UpperBound.__hash__<5F>rtrc<01>t<00>|jrdnd}d|jj<00>d|j<00>|<01>d<05>S)N<>]rZrwrxryrzr{s rr]z_UpperBound.__repr__<5F>s8<00><00><1D><1E><1E>#<23>S<EFBFBD><07><12>4<EFBFBD>><3E>><3E>*<2A>*<2A>+<2B>1<EFBFBD>T<EFBFBD>\<5C>\<5C>,<<3C>W<EFBFBD>I<EFBFBD>Q<EFBFBD>G<>GrNr}r`)rJr<>r^r(rbrdrrrrr<>r<><00>r<>rr<>Fztuple[_VersionRange]<5D> _FULL_RANGEc<01><><00>|j<00> |j<00>y|j|jk(r|jxr |j S|j|jkDS)zHTrue when the range defined by *lower* and *upper* contains no versions.Frk)<02>lower<65>uppers r<00>_range_is_emptyr<79><00>sQ<00><00> <0C>}<7D>}<7D><1C><05> <0A> <0A> 5<><14> <0C>}<7D>}<7D><05> <0A> <0A>%<25><19>O<EFBFBD>O<EFBFBD>7<><05><0F><0F>8<>8<> <10>=<3D>=<3D>5<EFBFBD>=<3D>=<3D> (<28>(rc<01>2<00>g}dx}}|t|<00>kr<>|t|<01>krt||\}}||\}}t||<07>} t||<08>}
t| |
<EFBFBD>s|j | |
f<02>||kr|dz }n|dz }|t|<00>kr|t|<01>kr<01>t|S)zFIntersect two sorted, non-overlapping range lists (two-pointer merge).rr )r#<00>max<61>minr<6E><00>append) <0B>left<66>right<68>result<6C>
left_index<EFBFBD> right_index<65>
left_lower<EFBFBD>
left_upper<EFBFBD> right_lower<65> right_upperr<72>r<>s r<00>_intersect_rangesr<73><00>s<><00><00>
#%<25>F<EFBFBD> <20> <20>J<EFBFBD><1B>
<14>s<EFBFBD>4<EFBFBD>y<EFBFBD>
<20>[<5B>3<EFBFBD>u<EFBFBD>:<3A>%=<3D>!%<25>j<EFBFBD>!1<><1E>
<EFBFBD>J<EFBFBD>#(<28><1B>#5<> <20> <0B>[<5B><13>J<EFBFBD> <0B>,<2C><05><13>J<EFBFBD> <0B>,<2C><05><1E>u<EFBFBD>e<EFBFBD>,<2C> <12>M<EFBFBD>M<EFBFBD>5<EFBFBD>%<25>.<2E> )<29> <16> <0B> #<23> <16>!<21>O<EFBFBD>J<EFBFBD> <17>1<EFBFBD> <1C>K<EFBFBD> <15>s<EFBFBD>4<EFBFBD>y<EFBFBD>
<20>[<5B>3<EFBFBD>u<EFBFBD>:<3A>%=<3D> <12>Mrc<01><><00>g|jdd<00>|jddz<00><01>}tj|j|d<04><05>S)z5Smallest version in the next prefix: 1.2 -> 1.3.dev0.N<><4E><EFBFBD><EFBFBD><EFBFBD>r r<00>rGr0rI)r0r<00>
from_partsrG)rAr0s r<00>_next_prefix_dev0r<30>sC<00><00>><3E><07><0F><0F><03><12>$<24>><3E>g<EFBFBD>o<EFBFBD>o<EFBFBD>b<EFBFBD>&9<>A<EFBFBD>&=<3D>><3E>G<EFBFBD> <12> <1D> <1D>G<EFBFBD>M<EFBFBD>M<EFBFBD>7<EFBFBD><01> J<>Jrc<01>Z<00>tj|j|jd<01><02>S)z7The .dev0 of a version's base release: 1.2 -> 1.2.dev0.rr<>)rr<>rGr0<00>rAs r<00>
_base_dev0r<EFBFBD>s <00><00> <12> <1D> <1D>G<EFBFBD>M<EFBFBD>M<EFBFBD>7<EFBFBD>?<3F>?<3F>PQ<50> R<>Rrc<01>`<00>t|t<00>s t|<00>}|S|S#t$rYywxYwr)r!rrr<>s r<00>_coerce_versionr<6E>$s:<00><00> <15>g<EFBFBD>w<EFBFBD> '<27> <18><1D>g<EFBFBD>&<26>G<EFBFBD> <13>N<EFBFBD>7<EFBFBD>N<EFBFBD><4E><1E> <18><17> <18>s <00> !<00> -<03>-c<01>B<00>|j<00>|S|jd<00><01>S)N)<01>local)r<><00> __replace__r<5F>s r<00>_public_versionr<6E>-s%<00><00><0E>}<7D>}<7D><1C><16><0E> <12> <1E> <1E>T<EFBFBD> <1E> *<2A>*rc<01>*<00>|jddd<01><02>S)zyThe version that *version* is a post-release of.
1.0.post1 -> 1.0, 1.0a1.post0 -> 1.0a1, 1.0.post0.dev1 -> 1.0.
N<>rHrIr<><00>r<>r<>s r<00>
_post_baser<EFBFBD>3s<00><00>
<13> <1E> <1E>D<EFBFBD>d<EFBFBD>$<24> <1E> ?<3F>?rc<01>(<00>|jdd<02><03>S)zZEarliest pre-release of *version*.
1.2 -> 1.2.dev0, 1.2.post1 -> 1.2.post1.dev0.
rN<>rIr<>r<>r<>s r<00>_earliest_prereleaser<65>;s<00><00>
<13> <1E> <1E>1<EFBFBD>D<EFBFBD> <1E> 1<>1rc<01>$<00>|<00>yt|t<00>r\|j}|jr|j ddd<01><02>S|j
<00>|j
dznd}|j |d<01><05>S|js|S|j ddd<01><02>S)z:Smallest non-pre-release version at or above *v*, or None.N)r)rIr<>r r)rHr<>)r!r>rA<00> is_prereleaser<65>rH)rK<00>inner<65>ks r<00>_nearest_non_prereleaser<65>Cs<><00><00> <09>y<EFBFBD><13><11>!<21>%<25>&<26><11> <09> <09><05> <10> <1E> <1E><18>$<24>$<24><14>4<EFBFBD>t<EFBFBD>$<24>D<> D<>!&<26>
<EFBFBD>
<EFBFBD> 6<>U<EFBFBD>Z<EFBFBD>Z<EFBFBD>!<21>^<5E>A<EFBFBD><01><14> <20> <20>a<EFBFBD>t<EFBFBD> <20>4<>4<> <0C>?<3F>?<3F><10><08> <0C>=<3D>=<3D>T<EFBFBD>t<EFBFBD>4<EFBFBD>=<3D> 8<>8rc<01><00>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)r5r6r7r8rrrrrXs<00><00>rrc<01><><00>eZdZdZdZedd<03><04>Zejdd<04><04>Z ejdd<05><04>Z
ejdd<06><04>Z eejdd<07><04><00>Z e jdd<08><04>Z ejddd
<EFBFBD><05>Zej d dd <0B><05>Zej d dd <0C><05>Zej d dd <0A><05>Zy )rr)<01>_strc<01><00>t|<00>S)z Internal property for match_args<67>r$rVs rr<>zBaseSpecifier._strhs<00><00><13>4<EFBFBD>y<EFBFBD>rc<01><00>y)z<>
Returns the str representation of this Specifier-like object. This
should be representative of the Specifier itself.
NrrVs r<00>__str__zBaseSpecifier.__str__m<00><00>rc<01><00>y)zF
Returns a hash value for this Specifier-like object.
NrrVs rrWzBaseSpecifier.__hash__tr<>rc<01><00>y)z<>
Returns a boolean representing whether or not the two Specifier-like
objects are equal.
:param other: The other object to check against.
NrrOs rrPzBaseSpecifier.__eq__zr<>rc<01><00>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.
NrrVs r<00> prereleaseszBaseSpecifier.prereleases<65>r<>rc<01><00>y)zQSetter for :attr:`prereleases`.
:param value: The value to set.
Nr<00>rCrRs rr<>zBaseSpecifier.prereleases<65>r<>rNc<01><00>y)zR
Determines if the given item is contained within this specifier.
Nr<00>rC<00>itemr<6D>s r<00>containszBaseSpecifier.contains<6E>r<>rc<01><00>yrr<00>rC<00>iterabler<65><00>keys r<00>filterzBaseSpecifier.filter<65><00><00><00> (+rc<01><00>yrrr<>s rr<>zBaseSpecifier.filter<65><00><00><00> rc<01><00>y)z<>
Takes an iterable of items and filters them so that only items which
are contained within this specifier are allowed in it.
Nrr<>s rr<>zBaseSpecifier.filter<65>r<>rrdrbr`<00>r^<00> bool | None)rRr(r^r_r)r<>r$r<>r<>r^r(<00>N.<2E>r<>zIterable[UnparsedVersionVar]r<>r<>r<>r_r^zIterator[UnparsedVersionVar]<5D>r<>z Iterable[T]r<>r<>r<>zCallable[[T], UnparsedVersion]r^z Iterator[T]<5D>NN<4E>r<><00> Iterable[Any]r<>r<>r<><00>'Callable[[Any], UnparsedVersion] | Noner^<00> Iterator[Any])r5r6r7re<00>__match_args__<5F>propertyr<79><00>abc<62>abstractmethodr<64>rWrPr<><00>setterr<72><00>typing<6E>overloadr<64>rrrrrds<><00><00><12>I<EFBFBD><1E>N<EFBFBD> <0A><19><0E><19> <09><17><17> <0C><18> <0C>  <09><17><17> <0C><18> <0C>
 <09><17><17> <0C><18> <0C><0E><08><17><17> <0C><18><0E> <0C><11><17><17> <0C><18> <0C>  <09><17><17> <0C><18> <0C>
 <0C>_<EFBFBD>_<EFBFBD>$(<28><17> +<2B>.<2E>+<2B>!<21>+<2B><12> +<2B>
&<26> +<2B><15>+<2B> <0C>_<EFBFBD>_<EFBFBD>$(<28>.1<EFBFBD> <1A><1D><1A>!<21><1A>,<2C> <1A>
<15> <1A><15><1A> <09><17><17>$(<28>7;<3B>  <0C><1F>  <0C>!<21>  <0C>5<>  <0C>
<17>  <0C><18>  rr)<01> metaclassc <01>\<00>eZdZUdZdZdZejdezdzejejz<00>Z
ddddd d
d d d <0A>Z de d<d1d2d<11>Z d3d<12>Zd4d<13>Zd5d<14>Zd6d<15>Zd6d<16>Zed7d<17><04>Zej*d8d<18><04>Zd9d<19>Zd:d<1A>Zed;d<1B><04>Zed;d<1C><04>Zd;d<1D>Zd;d<1E>Zed<d<1F><04>Zd=d <20>Zd>d!<21>Zd?d"<22>Zd@d#<23>Z dAd$<24>Z!d@d%<25>Z"d@d&<26>Z#d@d'<27>Z$d@d(<28>Z%dBd)<29>Z&dBd*<2A>Z'dCd+<2B>Z(dDd,<2C>Z)dEdFd-<2D>Z*e+jX dG dHd.<2E><05>Z-e+jX dG dId/<2F><05>Z- dJ dKd0<64>Z-y)Lra<>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.
)<05> _prereleases<65>_ranges<65>_spec<65> _spec_version<6F>_wildcard_splita 
(?:
(?:
# 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*<2A>
compatible<EFBFBD>equal<61> not_equal<61>less_than_equal<61>greater_than_equal<61> less_than<61> greater_than<61> arbitrary)<08>~=<3D>==<3D>!=<3D><=<3D>>=rwry<00>===r<00>
_operatorsNc<01><><00>|jj|<01>std|<01><02><02><00>|j<00>}|j d<02>r|dd|ddj<00>}}nB|j d<05>r|dd|ddj<00>}}n|dd|ddj<00>}}||f|_||_d|_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<>r<>r<>r r )
<EFBFBD>_regex<65> fullmatchr<00>strip<69>
startswithr<EFBFBD>r<>r<>r<>r<>)rCr%r<><00>operatorrAs rrEzSpecifier.__init__=s<><00><00><14>{<7B>{<7B>$<24>$<24>T<EFBFBD>*<2A>"<22>%8<><14><08>#A<>B<> B<><13>z<EFBFBD>z<EFBFBD>|<7C><04> <0F>?<3F>?<3F>5<EFBFBD> !<21> $<24>R<EFBFBD>a<EFBFBD><08>$<24>q<EFBFBD>r<EFBFBD>(<28>.<2E>.<2E>*:<3A>g<EFBFBD>H<EFBFBD> <11>_<EFBFBD>_<EFBFBD>;<3B> <<3C> $<24>R<EFBFBD>a<EFBFBD><08>$<24>q<EFBFBD>r<EFBFBD>(<28>.<2E>.<2E>*:<3A>g<EFBFBD>H<EFBFBD> $<24>R<EFBFBD>a<EFBFBD><08>$<24>q<EFBFBD>r<EFBFBD>(<28>.<2E>.<2E>*:<3A>g<EFBFBD>H<EFBFBD>'/<2F><17>&9<><04>
<EFBFBD>(<28><04><19>:><3E><04><1A>>B<01><04><1C>8<<3C><04> rc<01><><00>|j<00>!|jd|k(r|jdSt|<01>}|<02>y||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )r<>r<>)rCrA<00>version_specifiers r<00>_get_spec_versionzSpecifier._get_spec_versioncsY<00><00> <0F> <1D> <1D> )<29>d<EFBFBD>.@<40>.@<40><11>.C<>w<EFBFBD>.N<><17>%<25>%<25>a<EFBFBD>(<28> (<28>+<2B>G<EFBFBD>4<><19> <1C> $<24><17>%<25>'8<>9<><04><1A> <20> rc<01>0<00>|j|<01>}|<02>J<00>|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)rCrA<00> spec_versions r<00>_require_spec_versionzSpecifier._require_spec_versionos&<00><00> <1C>-<2D>-<2D>g<EFBFBD>6<> <0C><1B>'<27>'<27>'<27><1B>rc<01> <00>|j<00> |jS|j}|j}|dk(rt|_tS|j d<02>r|j ||<02>}n|j ||<02>}||_|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<><00>.*)r<>r<>rAr<><00>endswith<74>_wildcard_ranges<65>_standard_ranges)rC<00>op<6F>ver_strr<72>s r<00>
_to_rangeszSpecifier._to_rangesys|<00><00> <10><<3C><<3C> #<23><17><<3C><<3C> <1F> <11>]<5D>]<5D><02><16>,<2C>,<2C><07> <0A><15>;<3B>&<26>D<EFBFBD>L<EFBFBD><1E> <1E> <12> <1B> <1B>D<EFBFBD> !<21><19>*<2A>*<2A>2<EFBFBD>w<EFBFBD>7<>F<EFBFBD><19>*<2A>*<2A>2<EFBFBD>w<EFBFBD>7<>F<EFBFBD><1D><04> <0C><15> rc<01><><00>|j|dd<00>}t|<03>}t|<03>}|dk(rt|d<03>t |d<04>fgSt
t |d<04>ft|d<03>t fgS)N<><4E><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD>TF)rr<>r<>rgr<><00>_NEG_INF<4E>_POS_INF)rCr r <00>baser<65>r<>s rr zSpecifier._wildcard_ranges<65>sy<00><00><13>)<29>)<29>'<27>#<23>2<EFBFBD>,<2C>7<><04><1A>4<EFBFBD> <20><05>!<21>$<24>'<27><05> <0A><14>:<3A> <20><15><04>-<2D>{<7B>5<EFBFBD>%<25>/H<>I<>J<> J<><16>{<7B>5<EFBFBD>%<25>0<> 1<> <18><15><04> %<25>x<EFBFBD> 0<>
<EFBFBD>
rc<01><00>|j|<02>}|dk(rt|d<02>tfgS|dk(r+tt t |t j<00>d<02>fgS|dk(r<>|j<00>3|j|jdzd<00><06>}t|d<02>tfgS|j<00>4|j|jdzdd<00><08>}t|d<02>tfgStt |t j<00>d <09>tfgS|d
k(r?|jr|n|jdd<00><06>}|tkrgStt |d <09>fgSd |v}t |t j<00>}|r|n|}|d k(rt|d<02>t |d<02>fgS|d k(r$tt |d <09>ft|d <09>tfgS|dk(rA|j|jdd<00><10>} t|d<02>t t| <09>d <09>fgSt!d|<01><02><02><00>)Nr<4E>Tr<54>ryr r<>rr<>Frw<00>+r<>r<>r<>r<>)r0<00>Unknown operator: )rrgrrr<>r>r4r;rIr<>rHr<r<>r.r0r<><00>
ValueError)
rCr r rK<00> lower_verr-<00> has_local<61> after_localsr<73><00>prefixs
rr
zSpecifier._standard_ranges<65>s+<00><00> <10> &<26> &<26>w<EFBFBD> /<2F><01> <0A><14>:<3A> <20><11>D<EFBFBD>)<29>8<EFBFBD>4<>5<> 5<> <0A><14>:<3A><1D><1F> 0<><11>M<EFBFBD>4N<34>4N<34> O<>QU<51>V<><12><0E> <0E> <0E><13>9<EFBFBD><10>u<EFBFBD>u<EFBFBD> <20><1E>M<EFBFBD>M<EFBFBD>a<EFBFBD>e<EFBFBD>e<EFBFBD>a<EFBFBD>i<EFBFBD>t<EFBFBD>M<EFBFBD>D<> <09>$<24>Y<EFBFBD><04>5<>x<EFBFBD>@<40>A<>A<><10>v<EFBFBD>v<EFBFBD>!<21><1D>M<EFBFBD>M<EFBFBD>q<EFBFBD>v<EFBFBD>v<EFBFBD><01>z<EFBFBD>q<EFBFBD><04>M<EFBFBD>M<> <09>$<24>Y<EFBFBD><04>5<>x<EFBFBD>@<40>A<>A<> <20> 0<><11>M<EFBFBD>4M<34>4M<34> N<>PU<50>V<><1C><12><0E> <0E> <0E><13>9<EFBFBD><1B><1F><1F>A<EFBFBD>a<EFBFBD>m<EFBFBD>m<EFBFBD><01><14>m<EFBFBD>.N<>E<EFBFBD><14> <0C>$<24><19> <09><1D>{<7B>5<EFBFBD>%<25>8<>9<>:<3A> :<3A><18>7<EFBFBD>N<EFBFBD> <09>'<27><01>=<3D>+E<>+E<>F<> <0C><1E><01>L<EFBFBD><05> <0A><14>:<3A> <20><11>D<EFBFBD>)<29>;<3B>u<EFBFBD>d<EFBFBD>+C<>D<>E<> E<> <0A><14>:<3A><19>;<3B>q<EFBFBD>%<25>0<>1<><1C>U<EFBFBD>E<EFBFBD>*<2A>H<EFBFBD>5<><0E> <0E>
<0E><14>:<3A><16>]<5D>]<5D>1<EFBFBD>9<EFBFBD>9<EFBFBD>S<EFBFBD>b<EFBFBD>><3E>]<5D>:<3A>F<EFBFBD><1C>Q<EFBFBD><04>%<25>{<7B>3D<33>V<EFBFBD>3L<33>e<EFBFBD>'T<>U<><0E> <0E><19>-<2D>b<EFBFBD>V<EFBFBD>4<>5<>5rc<01><><00>|j<00> |jS|j\}}|dk(ry|dk(r|jd<04>ry|j|<02>}|<03>y|jS)Nr<4E>Fr<46>r)r<>r<>rrr<>)rCr<><00> version_strrAs rr<>zSpecifier.prereleases<65>sy<00><00> <10> <1C> <1C> (<28><17>$<24>$<24> $<24>!%<25>
<EFBFBD>
<EFBFBD><1D><08>+<2B> <13>t<EFBFBD> <1B><18> <14>t<EFBFBD> <1B> <0B> 4<> 4<>T<EFBFBD> :<3A><18><17>(<28>(<28><1B>5<><07> <12>?<3F><17><17>$<24>$<24>$rc<01><00>||_yr)r<>r<>s rr<>zSpecifier.prereleases<65>s
<00><00>!<21><04>rc<01>2<00>|j|jfSr)r<>r<>rVs r<00> __getstate__zSpecifier.__getstate__<5F>s<00><00><15>
<EFBFBD>
<EFBFBD>D<EFBFBD>-<2D>-<2D>.<2E>.rc<01>d<00>d|_d|_d|_t|t<00>r<>t |<01>dk(r*|\}}t |<02>rt|<03>r||_||_ yt |<01>dk(r`t|dt<00>rM|\}}|jd<03>}|jdd<05>}t |<02>rt|<03>r||_||_ yt|t<00>rH|jd<03>}|jdd<05>}t |<02>rt|<03>r||_||_ ytd|<01><02><02><00>)Nr r r<>r<><00>invalidzCannot restore Specifier from ) r<>r<>r<>r!r"r#r&r*r<>r<><00>dict<63>get<65> TypeError)rC<00>stater%r<><00>_<> slot_dicts r<00> __setstate__zSpecifier.__setstate__s<00><00>!<21><04><1A>#<23><04><1C><1B><04> <0C> <15>e<EFBFBD>U<EFBFBD> #<23><12>5<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD>$)<29>!<21><04>k<EFBFBD>!<21>$<24>'<27>M<EFBFBD>+<2B>,F<>!%<25>D<EFBFBD>J<EFBFBD>(3<>D<EFBFBD>%<25><1A><12>5<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD>:<3A>e<EFBFBD>A<EFBFBD>h<EFBFBD><04>#=<3D>$<24> <0C><01>9<EFBFBD> <20>}<7D>}<7D>W<EFBFBD>-<2D><04>'<27>m<EFBFBD>m<EFBFBD>N<EFBFBD>I<EFBFBD>F<> <0B>!<21>$<24>'<27>M<EFBFBD>+<2B>,F<>!%<25>D<EFBFBD>J<EFBFBD>(3<>D<EFBFBD>%<25><1A> <15>e<EFBFBD>T<EFBFBD> "<22><18>9<EFBFBD>9<EFBFBD>W<EFBFBD>%<25>D<EFBFBD><1F>)<29>)<29>N<EFBFBD>I<EFBFBD>><3E>K<EFBFBD><1D>d<EFBFBD>#<23> <0A>k<EFBFBD>(B<>!<21><04>
<EFBFBD>$/<2F><04>!<21><16><17>8<><15> <09>B<>C<>Crc<01> <00>|jdS)z`The operator of this specifier.
>>> Specifier("==1.2.3").operator
'=='
r<00>r<>rVs rr<>zSpecifier.operator$<00><00><00><14>z<EFBFBD>z<EFBFBD>!<21>}<7D>rc<01> <00>|jdS)zaThe version of this specifier.
>>> Specifier("==1.2.3").version
'1.2.3'
r r*rVs rrAzSpecifier.version-r+rc<01><><00>|j<00>d|j<00><02>nd}d|jj<00>dt |<00><00>|<01>d<05>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)>
<20>, prereleases=<3D>rwrY<00>)><3E>r<>r<>r[r5r$<00>rCr)s rr]zSpecifier.__repr__6sU<00><00><14> <20> <20>,<2C><1D>T<EFBFBD>-<2D>-<2D>0<> 1<><13> <0C> <13>4<EFBFBD>><3E>><3E>*<2A>*<2A>+<2B>1<EFBFBD>S<EFBFBD><14>Y<EFBFBD>M<EFBFBD>#<23><15>b<EFBFBD>A<>Arc<01>4<00>dj|j<00>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{}{})<02>formatr<74>rVs rr<>zSpecifier.__str__Hs<00><00><1D>v<EFBFBD>}<7D>}<7D>d<EFBFBD>j<EFBFBD>j<EFBFBD>)<29>)rc<01><><00>|j\}}|dk(s|jd<02>r||fS|j|<02>}t||dk7<00><04>}||fS)Nr<4E>rr<><00><01>strip_trailing_zero)r<>rrr)rCr<>rAr<00>canonical_versions r<00>_canonical_speczSpecifier._canonical_specRsc<00><00> <20>J<EFBFBD>J<EFBFBD><19><08>'<27> <13>u<EFBFBD> <1C><07> 0<> 0<><14> 6<><1B>W<EFBFBD>$<24> $<24><1B>1<>1<>'<27>:<3A> <0C>0<> <18>x<EFBFBD>4<EFBFBD>/?<3F>
<EFBFBD><19><18>*<2A>*<2A>*rc<01>,<00>t|j<00>Sr)rUr9rVs rrWzSpecifier.__hash__`s<00><00><13>D<EFBFBD>(<28>(<28>)<29>)rc<01><><00>t|t<00>r |jt|<01><00>}nt||j<00>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[rrNr9rOs rrPzSpecifier.__eq__csi<00><00>& <16>e<EFBFBD>S<EFBFBD> !<21> &<26><1C><0E><0E>s<EFBFBD>5<EFBFBD>z<EFBFBD>2<><05><1C>E<EFBFBD>4<EFBFBD>><3E>><3E>2<>!<21> !<21><13>#<23>#<23>u<EFBFBD>'<<3C>'<<3C><<3C><<3C><> $<24> &<26>%<25>%<25> &<26>s<00>A"<00>"A4<03>3A4c<01>><00>t|d|j|<00><00><02>}|S)N<> _compare_)<02>getattrr<72>)rCr <00>operator_callables r<00> _get_operatorzSpecifier._get_operator<6F>s+<00><00>.5<EFBFBD> <10>I<EFBFBD>d<EFBFBD>o<EFBFBD>o<EFBFBD>b<EFBFBD>1<>2<>3<>/
<EFBFBD><19>!<21> rc
<01><><00>tttjtt |<02><00><00>dd<00>}|dz }|j ||<02>xr|j||<03>S)Nr<4E>r)<08> _version_join<69>list<73> itertools<6C> takewhile<6C>_is_not_suffix<69>_version_split<69>_compare_greater_than_equal<61>_compare_equal)rC<00> prospectiver%rs r<00>_compare_compatiblezSpecifier._compare_compatible<6C>sd<00><00><1F> <10><19>$<24>$<24>^<5E>^<5E>D<EFBFBD>5I<35>J<> K<>C<EFBFBD>R<EFBFBD> P<>
<EFBFBD><06>
<0F>$<24><0E><06><14>0<>0<><1B>d<EFBFBD>C<>
<EFBFBD> <10> <1F> <1F> <0B>V<EFBFBD> 4<>
rc<01><><00>|j}|<02>/t|ddd<03><04>}t|<03>}|t|<04>f}||_|S)z<>Cached split of a wildcard spec into components and numeric length.
>>> Specifier("==1.*")._get_wildcard_split("1.*")
(['0', '1'], 2)
>>> Specifier("==3.10.*")._get_wildcard_split("3.10.*")
(['0', '3', '10'], 3)
NrFr6)r<>rrG<00>_numeric_prefix_len)rCr%<00>wildcard_split<69>
normalized<EFBFBD>
split_specs r<00>_get_wildcard_splitzSpecifier._get_wildcard_split<69>sO<00><00><1E>-<2D>-<2D><0E> <19> !<21>-<2D>d<EFBFBD>3<EFBFBD>B<EFBFBD>i<EFBFBD>U<EFBFBD>S<>J<EFBFBD>'<27>
<EFBFBD>3<>J<EFBFBD>(<28>*=<3D>j<EFBFBD>*I<>J<>N<EFBFBD>#1<>D<EFBFBD> <20><1D>rc<01>&<00>|jd<01>rT|j|<02>\}}tt|<01>d<02><03>}t |<05>}t ||<04>}|dt |<03>}||k(S|j|<02>} | js t|<01>}|| k(S)NrFr6) rrQrr<>rG<00> _left_padr#rr<>)
rCrJr%rP<00>spec_numeric_len<65>normalized_prospective<76>split_prospective<76>padded_prospective<76>shortened_prospectivers
rrIzSpecifier._compare_equal<61>s<><00><00> <0F>=<3D>=<3D><14> <1E>+/<2F>+C<>+C<>D<EFBFBD>+I<> (<28>J<EFBFBD>(<28>&:<3A><1F> <0B>,<2C>%<25>&<0E> "<22> !/<2F>/E<> F<> <1D>"+<2B>+<<3C>>N<>!O<> <1E>
%7<>7H<37><13>Z<EFBFBD><1F>$I<> !<21>(<28>J<EFBFBD>6<> 6<> <20>5<>5<>d<EFBFBD>;<3B>L<EFBFBD>
 <20>%<25>%<25>-<2D>k<EFBFBD>:<3A> <0B><1E>,<2C>.<2E> .rc<01>(<00>|j||<02> Sr)rI<00>rCrJr%s r<00>_compare_not_equalzSpecifier._compare_not_equal<61>s<00><00><17>&<26>&<26>{<7B>D<EFBFBD>9<>9<>9rc<01><<00>t|<01>|j|<02>kSr<00>r<>rrZs r<00>_compare_less_than_equalz"Specifier._compare_less_than_equal<61><00><00><00><1F>{<7B>+<2B>t<EFBFBD>/I<>/I<>$<24>/O<>O<>Orc<01><<00>t|<01>|j|<02>k\Srr]rZs rrHz%Specifier._compare_greater_than_equal<61>r_rc<01><><00>|j|<02>}||ksy|js|jr|t|<03>k\ryyr<>)rr<>r<><00>rCrJ<00>spec_strr%s r<00>_compare_less_thanzSpecifier._compare_less_than<61>sK<00><00><14>)<29>)<29>(<28>3<><04>
<1B>T<EFBFBD>!<21><18>
<15>"<22>"<22><1B>)<29>)<29><1B>3<>D<EFBFBD>9<>9<><18>
rc<01><><00>|j|<02>}||kDsy|js|jrt|<01>|k(ry|j<00>t |<01>|k(ryyr<>)r<00>is_postreleaser<65>r<>r<>rbs r<00>_compare_greater_thanzSpecifier._compare_greater_than<61>sg<00><00><14>)<29>)<29>(<28>3<><04>
<1B>T<EFBFBD>!<21><18>
<15>#<23>#<23><1B>*<2A>*<2A><1A>;<3B>'<27>4<EFBFBD>/<2F><18> <17> <1C> <1C> (<28>_<EFBFBD>[<5B>-I<>T<EFBFBD>-Q<><18>
rc<01>h<00>t|<01>j<00>t|<02>j<00>k(Sr<00>r$r<>rZs r<00>_compare_arbitraryzSpecifier._compare_arbitrarys&<00><00><12>;<3B><1F>%<25>%<25>'<27>3<EFBFBD>t<EFBFBD>9<EFBFBD>?<3F>?<3F>+<<3C><<3C><rc<01>$<00>|j|<01>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
<20>r<><00>rCr<>s r<00> __contains__zSpecifier.__contains__<00><00><00>&<14>}<7D>}<7D>T<EFBFBD>"<22>"rc<01>N<00>tt|j|g|<02><01><00><00>S)asReturn 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:`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
<20>r<>)r(rCr<>r<>s rr<>zSpecifier.contains.s#<00><00>2<14>D<EFBFBD><14><1B><1B>d<EFBFBD>V<EFBFBD><1B><1B>E<>F<>G<>Grc<01><00>yrrr<>s rr<>zSpecifier.filterIr<>rc<01><00>yrrr<>s rr<>zSpecifier.filterQr<>rc#<01>ZK<00>g}d}|<02>|n |j}|j|j<00>}|D]<5D>}t|<03>|n||<08><00>} d}
| <09>0|jdk(rj|j ||j
<00>rN|<08><01>nI|jdk(r'|j |<03>|n||<08>|j
<00>}
n|| |j
<00>}
|
s<01><>| <09><01><>| j r|rd}|<08><01><00><>|<02><01><>|jdus<01><>|j|<08><00><>|s|<02>|jdur |Ed{<00><02><02>yyyy7<00><08>w)a<>Filter items in the given iterable, that match the specifier.
:param iterable:
An iterable that can contain version strings and :class:`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:`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'}]
FNr<4E>T) r<>r@r<>r<>rjrAr<>r<>r<>) rCr<>r<>r<><00>prereleases_versions<6E>found_non_prereleases<65>include_prereleasesr?rA<00>parsed_version<6F>matchs rr<>zSpecifier.filterYsS<00><00><><00>F "<22><1C> %<25><1D>'<27>2<>K<EFBFBD><04>8H<38>8H<38> <1C>
!<21>.<2E>.<2E>t<EFBFBD>}<7D>}<7D>=<3D><19> <20> 9<>G<EFBFBD>,<2C><03> <0B>W<EFBFBD><13>W<EFBFBD><1C>V<>N<EFBFBD><19>E<EFBFBD><1D>%<25><17>=<3D>=<3D>E<EFBFBD>)<29>d<EFBFBD>.E<>.E<><1B>T<EFBFBD>\<5C>\<5C>/<12>"<22>M<EFBFBD><15><1D><1D>%<25>'<27><1C>/<2F>/<2F>"<22>{<7B>G<EFBFBD><03>G<EFBFBD> <0C>d<EFBFBD>l<EFBFBD>l<EFBFBD><12><05>*<2A>.<2E>$<24>,<2C>,<2C>G<><05><14><1E>3<>%<25>3<>3<>7J<37>,0<>)<29>!<21>M<EFBFBD> <20>(<28>T<EFBFBD>-><3E>-><3E>e<EFBFBD>-K<>(<28>/<2F>/<2F><07>8<>/ 9<>8&<26><1B>#<23><14>!<21>!<21><15>.<2E>+<2B> +<2B> +<2B>/<2F>$<24>&<26> ,<2C>s*<00>C D+<01> D+<01>D+<01>'D+<01>6*D+<01> D)<04>! D+<01>r/N)r%r$r<>r<>r^r_)rAr$r^<00>Version | None)rAr$r^r<00>r^<00>Sequence[_VersionRange])r r$r r$r^<00>list[_VersionRange]r<><00>rRr<>r^r_)r^z#tuple[tuple[str, str], bool | None]<5D>r%rar^r_rd)r^ztuple[str, str]rbr`)r r$r^<00>CallableOperator)rJrr%r$r^r()r%r$r^ztuple[list[str], int])rJrrcr$r^r()rJz Version | strr%r$r^r()r<>z str | Versionr^r(r)r<><00>UnparsedVersionr<6E>r<>r^r(r<>r<>r<>r<>r<>).r5r6r7r8re<00>_specifier_regex_str<74>re<72>compile<6C>VERBOSE<53>
IGNORECASEr<EFBFBD>r<><00>__annotations__rErrr r r
r<>r<>r<>rr(r<>rAr]r<>r9rWrPr@rKrQrIr[r^rHrdrgrjrnr<>r<>r<>r<>rrrrr<00>s<00><00><08>&<06>I<EFBFBD>Z <0C><18>x<18>R<EFBFBD>Z<EFBFBD>Z<EFBFBD><0E>%<25>%<25><06>.<2E><02>
<EFBFBD>
<EFBFBD>R<EFBFBD>]<5D>]<5D>0J<30><06>F<EFBFBD>
<1B><15><19><1F>"<22> <18> <1B><1A> <06>J<EFBFBD><05> <06>$<<3C>L
!<21><1C><16>0 
<EFBFBD><6<>|<0E>%<25><0E>%<25>6<11><17><17>"<22><18>"<22>/<2F> D<01>D<0E><1D><0E><1D><0E><1D><0E><1D>B<01>$*<2A><0E> +<2B><0E> +<2B>*<2A>=<3D>:!<21> 
<EFBFBD>(<1E> "/<2F>H:<3A>P<01> P<01> <14>2<14>@=<3D>#<23>*H<01>6 <0C>_<EFBFBD>_<EFBFBD>$(<28><17> +<2B>.<2E>+<2B>!<21>+<2B><12> +<2B>
&<26> +<2B><15>+<2B> <0C>_<EFBFBD>_<EFBFBD>$(<28>.1<EFBFBD> <1A><1D><1A>!<21><1A>,<2C> <1A>
<15> <1A><15><1A>$(<28>7;<3B> O,<2C><1F>O,<2C>!<21>O,<2C>5<> O,<2C>
<17> O,rrz([0-9]+)((?:a|b|c|rc)[0-9]+)c#<01>0K<00>g}g}d}|D]v}t|<01>|n||<05><00>}|<06>*|r|<05><01>n"|j|<05>|j|<05><00>D|js|s |Ed{<00><02><02>d}|<05><01><00>c|r<01>f|j|<05><00>x|s |Ed{<00><02><02>yy7<00>/7<00><08>w)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r<>r<>r<>)r<>r<><00> all_nonfinal<61>arbitrary_strings<67> found_finalr<6C><00>parseds r<00>_pep440_filter_prereleasesr<73><00>s<><00><00><><00>!<21>L<EFBFBD>#%<25><15><17>K<EFBFBD><18>&<26><04> <20><13><1B><14>#<23>d<EFBFBD>)<29>D<><06> <11>><3E><1B><1A>
<EFBFBD>!<21>(<28>(<28><14>.<2E><1C>#<23>#<23>D<EFBFBD>)<29> <14><15>#<23>#<23><1E>,<2C>,<2C>,<2C>"<22> <0B><16>J<EFBFBD> <14><1B> <18> <1F> <1F><04> %<25>1&<26>6 <17><1F><1F><1F> <17>-<2D><> <20>s*<00>A B<01>"B<06># B<01>1B<01> B<04> B<01>Bc<01><00>g}|jd<01>\}}}|j|xsd<02>|jd<03>D]J}tj |<05>}|r |j |j <00><00><00>:|j|<05><00>L|S)aSplit version into components.
The split components are intended for version comparison. The logic does
not attempt to retain the original version string, so joining the
components back with :func:`_version_join` may not produce the original
version string.
<20>!<21>0<>.)<07>
rpartitionr<EFBFBD><00>split<69> _prefix_regexr<78><00>extend<6E>groups)rAr<>rGr&<00>restr<74>rys rrGrG<00>s~<00><00><1B>F<EFBFBD><1C>'<27>'<27><03>,<2C>N<EFBFBD>E<EFBFBD>1<EFBFBD>d<EFBFBD>
<EFBFBD>M<EFBFBD>M<EFBFBD>%<25>,<2C>3<EFBFBD><1F><14>
<EFBFBD>
<EFBFBD>3<EFBFBD><0F> <20><04><1D>'<27>'<27><04>-<2D><05> <10> <12>M<EFBFBD>M<EFBFBD>%<25>,<2C>,<2C>.<2E> )<29> <12>M<EFBFBD>M<EFBFBD>$<24> <1F>  <20> <12>Mrc<01>6<00>|^}}|<01>ddj|<02><00><00>S)z<>Join split version components into a version string.
This function assumes the input came from :func:`_version_split`, where the
first component must be the epoch (either empty or numeric), and all other
components numeric.
r<>r<>)<01>join)<03>
componentsrGr<>s rrBrB<00>s'<00><00><1E>L<EFBFBD>E<EFBFBD>D<EFBFBD><13>W<EFBFBD>A<EFBFBD>c<EFBFBD>h<EFBFBD>h<EFBFBD>t<EFBFBD>n<EFBFBD>%<25> &<26>&rc<01>.<00><00>t<00>fd<01>dD<00><00> S)Nc3<01>@<00>K<00>|]}<01>j|<01><00><01><00>y<00>wr)r<>)<03>.0r<00>segments <20>r<00> <genexpr>z!_is_not_suffix.<locals>.<genexpr><3E>s!<00><><00><><00><06>'-<2D><07><1A><1A>6<EFBFBD>"<22><06><><00>)rI<00>a<>b<>rcrH)<01>any)r<>s`rrFrF<00>s"<00><><00><12><06>1P<31><06><06> <06>rc<01>H<00>d}|D]}|j<00>s|S|dz }<01>|S)z<>Count leading numeric components in a :func:`_version_split` result.
>>> _numeric_prefix_len(["0", "1", "2", "a1"])
3
rr )<01>isdigit)r<><00>countr<74>s rrMrM<00>s<<00><00> <0E>E<EFBFBD><18><13><07><16><EFBFBD><EFBFBD> <20> <11> <10>L<EFBFBD> <0E><11>
<EFBFBD><05><13> <11>Lrc<01>T<00>t|<00>}||z
}|dkr|Sg|d|<00>dg|z<00>||d<00>S)z<>Pad a :func:`_version_split` result with ``"0"`` segments to reach
``target_numeric_len`` numeric components. Suffix segments are preserved.
>>> _left_pad(["0", "1", "a1"], 4)
['0', '1', '0', '0', 'a1']
rNr<4E>)rM)r<><00>target_numeric_len<65> numeric_len<65>
pad_neededs rrSrS sN<00><00>&<26>e<EFBFBD>,<2C>K<EFBFBD>#<23>k<EFBFBD>1<>J<EFBFBD><11>Q<EFBFBD><EFBFBD><14> <0C> N<>U<EFBFBD><<3C>K<EFBFBD> <20> N<>S<EFBFBD>E<EFBFBD>J<EFBFBD>$6<> N<>%<25> <0B> <0C>:M<> N<>Nrc<01><><00>|\}}}|dk(r|jd<02>sdSdS|dvry|dk(ry|dk(r|jd<02>sd Sd
S|d k(rytd |<03><02><02><00>) aLSort key for Cost Based Ordering of specifier operators in _filter_versions.
Operators run sequentially on a shrinking candidate set, so operators that
reject the most versions should run first to minimize work for later ones.
Tier 0: Exact equality (==, ===), likely to narrow candidates to one version
Tier 1: Range checks (>=, <=, >, <), cheap and usually reject a large portion
Tier 2: Wildcard equality (==.*) and compatible release (~=), more expensive
Tier 3: Exact !=, cheap but rarely rejects
Tier 4: Wildcard !=.*, expensive and rarely rejects
r<>rrr )r<>r<>ryrwr r<>r<>r<00>r<>r)rr)<04>op_entryr&<00>verr s r<00>_operator_costr<74>s|<00><00><1A>J<EFBFBD>A<EFBFBD>s<EFBFBD>B<EFBFBD> <09>T<EFBFBD>z<EFBFBD><1B> <0C> <0C>T<EFBFBD>*<2A>q<EFBFBD>1<><01>1<> <09> #<23>#<23><10> <09>T<EFBFBD>z<EFBFBD><10> <09>T<EFBFBD>z<EFBFBD><1B> <0C> <0C>T<EFBFBD>*<2A>q<EFBFBD>1<><01>1<> <09>U<EFBFBD>{<7B><10>
<14>)<29>"<22><16>0<>
1<EFBFBD>1rc<01><><00>eZdZdZdZ d dd<04>Zdd<05>Zedd<06><04>Zejdd<07><04>Zd d<08>Z
d!d <09>Z d"d
<EFBFBD>Z d"d <0B>Z d#d <0C>Zd$d <0A>Zd%d<0E>Zd#d<0F>Zd&d<10>Zd'd<11>Zd(d<12>Zd(d<13>Zd(d<14>Zd)d<15>Z d* d+d<16>Zej4 d, d-d<17><05>Zej4 d, d.d<18><05>Z d* d/d<19>Z d0 d1d<1A>Zy)2ra<>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.
)<06>_canonicalized<65>_has_arbitrary<72>_is_unsatisfiabler<65><00> _resolved_ops<70>_specsNc<01><><00>t|t<00>re|jd<01>D<00>cgc]#}|j<00>s<01>|j<00><00><02>%}}t t t |<04><00>|_d|v|_n1t |<01>|_td<03>|jD<00><00>|_t|j<00>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.
<20>,r<>c3<01>6K<00>|]}dt|<01>v<00><01><00>y<01>w<01>r<>Nr<4E><00>r<><00>ss rr<>z(SpecifierSet.__init__.<locals>.<genexpr>ts<00><00><><00>%K<>!<21>e<EFBFBD>s<EFBFBD>1<EFBFBD>v<EFBFBD>o<EFBFBD>%K<><4B><00>r N)r!r$r<>r<>r"<00>maprr<>r<>r<>r#r<>r<>r<>r<>)rC<00>
specifiersr<EFBFBD>r<><00>split_specifierss rrEzSpecifierSet.__init__Rs<><00><00>, <16>j<EFBFBD>#<23> &<26>4><3E>3C<33>3C<33>C<EFBFBD>3H<33>V<>a<EFBFBD>A<EFBFBD>G<EFBFBD>G<EFBFBD>I<EFBFBD><01><07><07> <09>V<> <1C>V<>16<31>s<EFBFBD>9<EFBFBD>FV<46>7W<37>1X<31>D<EFBFBD>K<EFBFBD>"'<27>:<3A>"5<>D<EFBFBD> <1F><1F>
<EFBFBD>+<2B>D<EFBFBD>K<EFBFBD>#&<26>%K<>t<EFBFBD>{<7B>{<7B>%K<>"K<>D<EFBFBD> <1F>!<21>$<24>+<2B>+<2B>.<2E>!<21>3<><04><1B>MQ<4D><04><1A>(<28><04><19>.2<EFBFBD><04><1E><>% Ws
<00>C<04>Cc<01><><00>|jsQttjt |j
t <00><01><00><00>|_d|_d|_d|_|j
S)zBDeduplicate, sort, and cache specs for order-sensitive operations.<2E>r<>TN) r<>r"r"<00>fromkeys<79>sortedr<64>r$r<>r<>rVs r<00>_canonical_specszSpecifierSet._canonical_specssM<00><00><13>"<22>"<22><1F><04> <0A> <0A>f<EFBFBD>T<EFBFBD>[<5B>[<5B>c<EFBFBD>.J<> K<>L<>D<EFBFBD>K<EFBFBD>"&<26>D<EFBFBD> <1F>!%<25>D<EFBFBD> <1E>%)<29>D<EFBFBD> "<22><13>{<7B>{<7B>rc<01><><00>|j<00> |jS|jsytd<01>|jD<00><00>ryy)Nc3<01>4K<00>|]}|j<00><01><00>y<00>wrrqr<>s rr<>z+SpecifierSet.prereleases.<locals>.<genexpr><3E>s<00><00><><00>2<><11>q<EFBFBD>}<7D>}<7D>2<>s<00>T)r<>r<>r<>rVs rr<>zSpecifierSet.prereleases<65>sB<00><00> <10> <1C> <1C> (<28><17>$<24>$<24> $<24>
<14>{<7B>{<7B><17> <0F>2<>d<EFBFBD>k<EFBFBD>k<EFBFBD>2<> 2<><17>rc<01> <00>||_d|_yr)r<>r<>r<>s rr<>zSpecifierSet.prereleases<65>s<00><00>!<21><04><19>!%<25><04>rc<01>2<00>|j|jfSr)r<>r<>rVs rrzSpecifierSet.__getstate__<5F>s<00><00><15> <0B> <0B>T<EFBFBD>.<2E>.<2E>/<2F>/rc<01><><00>d|_d|_t|t<00><00>rft |<01>dk(rk|\}}t|t<00>rVt d<02>|D<00><00>rDt |<03>r9||_||_t |<02>dk|_ td<04>|D<00><00>|_ yt |<01>dk(r<>t|dt<00>r<>|\}}|jdd<06>}|jd<07>}t|t<00>rtt|t <00><08><00>}t|t<00>rjt d <09>|D<00><00>rXt |<03>rM||_||_t |j<00>dk|_ td
<EFBFBD>|jD<00><00>|_ yt|t<00>r<>|jdd<06>}|jd<07>}t|t<00>rtt|t <00><08><00>}t|t<00>rjt d <0B>|D<00><00>rXt |<03>rM||_||_t |j<00>dk|_ td <0C>|jD<00><00>|_ yt#d |<01><02><02><00>)Nr c3<01><K<00>|]}t|t<00><00><01><00>y<00>wr<00>r!rr<>s rr<>z,SpecifierSet.__setstate__.<locals>.<genexpr><3E><00><00><00><><00>D<><11>J<EFBFBD>q<EFBFBD>)<29>4<>D<><44><00>r c3<01>6K<00>|]}dt|<01>v<00><01><00>y<01>wr<>r<>r<>s rr<>z,SpecifierSet.__setstate__.<locals>.<genexpr><3E>s<00><00><><00>-M<>!<21>e<EFBFBD>s<EFBFBD>1<EFBFBD>v<EFBFBD>o<EFBFBD>-M<>r<EFBFBD>r<>rr<>r<>c3<01><K<00>|]}t|t<00><00><01><00>y<00>wrr<>r<>s rr<>z,SpecifierSet.__setstate__.<locals>.<genexpr><3E>r<>r<>c3<01>6K<00>|]}dt|<01>v<00><01><00>y<01>wr<>r<>r<>s rr<>z,SpecifierSet.__setstate__.<locals>.<genexpr><3E>s<00><00><><00>-S<>!<21>e<EFBFBD>s<EFBFBD>1<EFBFBD>v<EFBFBD>o<EFBFBD>-S<>r<EFBFBD>c3<01><K<00>|]}t|t<00><00><01><00>y<00>wrr<>r<>s rr<>z,SpecifierSet.__setstate__.<locals>.<genexpr><3E>s<00><00><><00>@<40>Q<EFBFBD>
<EFBFBD>1<EFBFBD>i<EFBFBD>0<>@<40>r<EFBFBD>c3<01>6K<00>|]}dt|<01>v<00><01><00>y<01>wr<>r<>r<>s rr<>z,SpecifierSet.__setstate__.<locals>.<genexpr><3E>s<00><00><><00>)O<>a<EFBFBD>%<25>3<EFBFBD>q<EFBFBD>6<EFBFBD>/<2F>)O<>r<EFBFBD>z!Cannot restore SpecifierSet from )r<>r<>r!r"r#<00>allr*r<>r<>r<>r<>r<>r"r#<00> frozensetr<74>r$r$)rCr%<00>specsr<73>r&r's rr(zSpecifierSet.__setstate__<5F>s<><00><00>!<21><04><1A>!%<25><04><1E> <15>e<EFBFBD>U<EFBFBD> #<23><12>5<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD>%*<2A>"<22><05>{<7B><1E>u<EFBFBD>e<EFBFBD>,<2C><1B>D<>e<EFBFBD>D<>D<>%<25>k<EFBFBD>2<>"'<27>D<EFBFBD>K<EFBFBD>(3<>D<EFBFBD>%<25>*-<2D>e<EFBFBD>*<2A><01>/<2F>D<EFBFBD>'<27>*-<2D>-M<>u<EFBFBD>-M<>*M<>D<EFBFBD>'<27><1A><12>5<EFBFBD>z<EFBFBD>Q<EFBFBD><EFBFBD>:<3A>e<EFBFBD>A<EFBFBD>h<EFBFBD><04>#=<3D>$<24> <0C><01>9<EFBFBD>!<21> <0A> <0A>h<EFBFBD><02>3<><05>'<27>m<EFBFBD>m<EFBFBD>N<EFBFBD>;<3B> <0B><1D>e<EFBFBD>Y<EFBFBD>/<2F>!<21>&<26><15>C<EFBFBD>"8<>9<>E<EFBFBD><1E>u<EFBFBD>e<EFBFBD>,<2C><1B>D<>e<EFBFBD>D<>D<>%<25>k<EFBFBD>2<>"'<27>D<EFBFBD>K<EFBFBD>(3<>D<EFBFBD>%<25>*-<2D>d<EFBFBD>k<EFBFBD>k<EFBFBD>*:<3A>a<EFBFBD>*?<3F>D<EFBFBD>'<27>*-<2D>-S<>t<EFBFBD>{<7B>{<7B>-S<>*S<>D<EFBFBD>'<27><1A> <15>e<EFBFBD>T<EFBFBD> "<22><19>I<EFBFBD>I<EFBFBD>h<EFBFBD><02>+<2B>E<EFBFBD><1F>)<29>)<29>N<EFBFBD>3<>K<EFBFBD><19>%<25><19>+<2B><1D>f<EFBFBD>U<EFBFBD><03>4<>5<><05><1A>5<EFBFBD>%<25>(<28><17>@<40>%<25>@<40>@<40>!<21>+<2B>.<2E>#<23><04> <0B>$/<2F><04>!<21>&)<29>$<24>+<2B>+<2B>&6<>!<21>&;<3B><04>#<23>&)<29>)O<>4<EFBFBD>;<3B>;<3B>)O<>&O<><04>#<23><16><17>;<3B>E<EFBFBD>9<EFBFBD>E<>F<>Frc<01><><00>|j<00>d|j<00><02>nd}d|jj<00>dt |<00><00>|<01>d<05>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/rwrYr0r1r2s rr]zSpecifierSet.__repr__<5F>sU<00><00><14> <20> <20>,<2C><1D>T<EFBFBD>-<2D>-<2D>0<> 1<><13> <0C> <13>4<EFBFBD>><3E>><3E>*<2A>*<2A>+<2B>1<EFBFBD>S<EFBFBD><14>Y<EFBFBD>M<EFBFBD>#<23><15>b<EFBFBD>A<>Arc<01>N<00>djd<02>|j<00>D<00><00>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<01>2K<00>|]}t|<01><00><01><00>y<00>wrr<>r<>s rr<>z'SpecifierSet.__str__.<locals>.<genexpr>s<00><00><><00>@<40>1<EFBFBD><03>A<EFBFBD><06>@<40>s<00>)r<>r<>rVs rr<>zSpecifierSet.__str__<5F>s"<00><00><13>x<EFBFBD>x<EFBFBD>@<40><04>(=<3D>(=<3D>(?<3F>@<40>@<40>@rc<01>4<00>t|j<00><00>Sr)rUr<>rVs rrWzSpecifierSet.__hash__s<00><00><13>D<EFBFBD>)<29>)<29>+<2B>,<2C>,rc<01><00>t|t<00>r t|<01>}nt|t<00>stSt<00>}|j|jz|_t |j<00>dk|_|jxs |j|_d|_|j<00>|j|jk(r|j|_ |S|j<00>|j|_ |Std<03><00>)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 NzFCannot combine SpecifierSets with True and False prerelease overrides.) r!r$rrNr<>r#r<>r<>r<>r<>r)rCrJ<00> specifiers r<00>__and__zSpecifierSet.__and__s<><00><00> <16>e<EFBFBD>S<EFBFBD> !<21> <20><15>'<27>E<EFBFBD><1B>E<EFBFBD><<3C>0<>!<21> !<21> <20>N<EFBFBD> <09><1F>;<3B>;<3B><15><1C><1C>5<> <09><18>#&<26>y<EFBFBD>'7<>'7<>#8<>A<EFBFBD>#=<3D> <09> <20>#'<27>#6<>#6<>#N<>%<25>:N<>:N<> <09> <20>"&<26> <09><1F> <10> <1C> <1C> $<24><04>(9<>(9<>U<EFBFBD>=O<>=O<>(O<>%*<2A>%7<>%7<>I<EFBFBD> "<22><19><18><13> <1F> <1F> '<27>%)<29>%6<>%6<>I<EFBFBD> "<22> <19><18> <1D>X<><0E> rc<01><><00>t|ttf<02>rtt|<01><00>}nt|t<00>stS|j <00>|j <00>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$rrrNr<>rOs rrPzSpecifierSet.__eq__&sN<00><00>& <16>e<EFBFBD>c<EFBFBD>9<EFBFBD>-<2D> .<2E> <20><13>U<EFBFBD><1A>,<2C>E<EFBFBD><1B>E<EFBFBD><<3C>0<>!<21> !<21><13>$<24>$<24>&<26>%<25>*@<40>*@<40>*B<>B<>Brc<01>,<00>t|j<00>S)z7Returns the number of specifiers in this specifier set.)r#r<>rVs r<00>__len__zSpecifierSet.__len__@s<00><00><12>4<EFBFBD>;<3B>;<3B><1F>rc<01>,<00>t|j<00>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')>]
)<02>iterr<72>rVs r<00>__iter__zSpecifierSet.__iter__Ds<00><00><14>D<EFBFBD>K<EFBFBD>K<EFBFBD> <20> rc<01><><00>|j}d}|D]3}|<02>|j<00>}<02>t||j<00><00>}|r<01>3n|<02> td<02><00>|S)aIntersect all specifiers into a single list of version ranges.
Returns an empty list when unsatisfiable. ``===`` specs are
modeled as full range; string matching is checked separately
by :meth:`_check_arbitrary_unsatisfiable`.
Nz _get_ranges called with no specs)r<>r r<><00> RuntimeError)rCr<>r<>r<>s r<00> _get_rangeszSpecifierSet._get_rangesNsa<00><00><15> <0B> <0B><05>15<31><06><16> <1A>A<EFBFBD><15>~<7E><1A><1C><1C><1E><06>*<2A>6<EFBFBD>1<EFBFBD><<3C><<3C>><3E>B<><06><1D><19>  <1A> <12>><3E><1E>A<>B<> B<><15> rc<01><><00>|j}|<01>|S|jsd|_y|j<00> }|s|j<00>}|s|jdur|j <00>}||_|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
F)r<>r<>r<><00>_check_arbitrary_unsatisfiabler<65><00>_check_prerelease_only_ranges)rC<00>cachedr<64>s r<00>is_unsatisfiablezSpecifierSet.is_unsatisfiabledsy<00><00><16>'<27>'<27><06> <11> <1D><19>M<EFBFBD><13>{<7B>{<7B>%*<2A>D<EFBFBD> "<22><18><19>%<25>%<25>'<27>'<27><06><15><19>8<>8<>:<3A>F<EFBFBD><15>$<24>*<2A>*<2A>e<EFBFBD>3<><19>7<>7<>9<>F<EFBFBD>!'<27><04><1E><15> rc<01><><00>|j<00>D]Y\}}t|j<00>}|<03>y|j<00>||jkry||jk(s<01>L|js<01>Yyy)z<>With prereleases=False, check if every range contains only
pre-release versions (which would be excluded from matching).FT)r<>r<>rAri)rCr<>r<><00>nearests rr<>z*SpecifierSet._check_prerelease_only_ranges<65>sh<00><00>!<21>,<2C>,<2C>.<2E> <1D>L<EFBFBD>E<EFBFBD>5<EFBFBD>-<2D>e<EFBFBD>m<EFBFBD>m<EFBFBD><<3C>G<EFBFBD><16><EFBFBD><1C><14>}<7D>}<7D>$<24><07>%<25>-<2D>-<2D>(?<3F><1C><16>%<25>-<2D>-<2D>'<27>E<EFBFBD>O<EFBFBD>O<EFBFBD><1C> <1D>rc<01><><00><04><05>|jD<00>cgc]}|jdk(s<01>|<01><02>}}|sy|djj<00><00>t <00>fd<04>|ddD<00><00>ryt |dj<00><00>|j dur<0F><04> <0A>jry|jD<00>cgc]}|jdk7s<01>|<01><02>}}|sy<02><04>yt<00>fd<08>|D<00><00> 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<01>X<00>K<00>|]!}|jj<00><00>k7<00><01><00>#y<00>wr)rAr<>)r<>r<><00>firsts <20>rr<>z>SpecifierSet._check_arbitrary_unsatisfiable.<locals>.<genexpr><3E>s!<00><><00><><00>A<>a<EFBFBD>q<EFBFBD>y<EFBFBD>y<EFBFBD><EFBFBD><EFBFBD> <20>E<EFBFBD>)<29>A<>s<00>'*r NTc3<01>@<00>K<00>|]}|j<00><02><00><01><00>y<00>wrrl)r<>r<><00> candidates <20>rr<>z>SpecifierSet._check_arbitrary_unsatisfiable.<locals>.<genexpr><3E>s<00><><00><><00>?<3F><11>q<EFBFBD>z<EFBFBD>z<EFBFBD>)<29>,<2C>?<3F>r<EFBFBD>) r<>r<>rAr<>r<>r<>r<>r<>r<>)rCr<>r<><00>standardr<64>r<>s @@rr<>z+SpecifierSet._check_arbitrary_unsatisfiable<6C>s<><00><><00>!%<25> <0B> <0B>C<>1<EFBFBD>q<EFBFBD>z<EFBFBD>z<EFBFBD>U<EFBFBD>/B<>Q<EFBFBD>C<> <09>C<><18><18><1A>!<21> <0C>$<24>$<24>*<2A>*<2A>,<2C><05> <0E>A<>9<EFBFBD>Q<EFBFBD>R<EFBFBD>=<3D>A<> A<><17>$<24>I<EFBFBD>a<EFBFBD>L<EFBFBD>$8<>$8<>9<> <09>
<11> <1C> <1C><05> %<25><19>%<25><19>'<27>'<27><17>#<23>{<7B>{<7B>B<>!<21>a<EFBFBD>j<EFBFBD>j<EFBFBD>E<EFBFBD>.A<>A<EFBFBD>B<><08>B<><17><18> <14> <1C><17><16>?<3F>h<EFBFBD>?<3F>?<3F>?<3F>?<3F><>=D<01><>,Cs<00>C<04>C<04>'C"<04><C"c<01>$<00>|j|<01>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
rlrms rrnzSpecifierSet.__contains__<5F>rorc<01><><00>t|<01>}|<04>|r|jrd}|<04>|jrt|t<00>s|}n|}t t |j|g|<02><02><00><00>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:`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
Trq)r<>r<>r<>r!rr(rCr<>)rCr<>r<><00> installedrA<00>
check_items rr<>zSpecifierSet.contains<6E>se<00><00>@"<22>$<24>'<27><07> <12> <1E>9<EFBFBD><17>1F<31>1F<31><1E>K<EFBFBD> <13>?<3F>t<EFBFBD>2<>2<>:<3A>d<EFBFBD>G<EFBFBD>;T<><1D>J<EFBFBD> <20>J<EFBFBD><13>D<EFBFBD><14><1B><1B>j<EFBFBD>\<5C>{<7B><1B>K<>L<>M<>Mrc<01><00>yrrr<>s rr<>zSpecifierSet.filter<65>r<>rc<01><00>yrrr<>s rr<>zSpecifierSet.filterr<>rc<01>t<00><03><05>|<02>|j<00> |j}|jrft|j<00>dk(r&|jdj||<02>dn|<02><03><04>}n|j |<01>|<02>dn|<02><05>}|<02>|St |<04><03>S|dur t |<01>S|dur <0C><03>fd<07>|D<00>St |<01><03>S)acFilter items in the given iterable, that match the specifiers in this set.
:param iterable:
An iterable that can contain version strings and :class:`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:`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']
r rT)r<>r<>rqFc3<01>j<00>K<00>|]*}t<00><02>|n<00>|<01><00>x<01> <00> <0C>js|<01><01><00>,y<00>wr)r<>r<>)r<>r<>r<>rAs <20><>rr<>z&SpecifierSet.filter.<locals>.<genexpr>^sA<00><><00><><00><0E><18> /<2F><03> <0B><04><13>T<EFBFBD><19> S<>S<>W<EFBFBD><1B><1C>"<22>0<>0<> <15><0E>s<00>03)r<>r<>r#r<><00>_filter_versionsr<73>r<>)rCr<>r<>r<><00>filteredrAs ` @rr<>zSpecifierSet.filter s<><00><><00>d <17> <1E>4<EFBFBD>#3<>#3<>#?<3F><1E>*<2A>*<2A>K<EFBFBD> <10>;<3B>;<3B> <13>4<EFBFBD>;<3B>;<3B><1F>1<EFBFBD>$<24><1F>;<3B>;<3B>q<EFBFBD>><3E>0<>0<><1C>(3<>(;<3B><04><1B><1B>1<><12><08>  <20>0<>0<><1C><17>(3<>(;<3B><04><1B>1<><12><08> <1B>&<26><1F><0F>-<2D>h<EFBFBD><03><<3C> <<3C> <17>$<24> <1E><17><08>><3E> !<21> <16>%<25> <1F><0E>$<24><0E> <0E>*<2A>(<28>C<EFBFBD>8<>8rc#<01>\<00><02><06>K<00>|j<00>'td<02>|jD<00>t<00><03>|_|j}|du}|D]]<00>t <00><02><02>n<00><02><06><00><00><07><07>t <00>fd<05>|D<00><00>s<01>/<2F><06><01><00>4|r <0A>j r<01>Ct <00><06><02>fd<06>|D<00><00>s<01>Z<EFBFBD><06><01><00>_y<01>w)a?Filter versions against all specifiers in a single pass.
Uses Cost Based Ordering: specifiers are sorted by _operator_cost so
that cheap range operators reject versions early, avoiding expensive
wildcard or compatible operators on versions that would have been
rejected anyway.
Nc3<01><>K<00>|]6}|j|j<00>|j|jf<03><01><00>8y<00>wr)r@r<>rA)r<>r%s rr<>z0SpecifierSet._filter_versions.<locals>.<genexpr>{s6<00><00><><00><12><1C><1A>'<27>'<27><04> <0A> <0A>6<><04> <0C> <0C>d<EFBFBD>m<EFBFBD>m<EFBFBD>T<><12>s<00><>r<>Fc3<01><><00>K<00>|]9\}}}|dk(xr*t<00><04>j<00>|j<00>k(<00><01><00>;y<01>wr<>ri)r<>r&r<>r r<>s <20>rr<>z0SpecifierSet._filter_versions.<locals>.<genexpr><3E>sA<00><><00><><00><12>"<22><01>3<EFBFBD><02><17>%<25>K<EFBFBD>D<>C<EFBFBD><04>I<EFBFBD>O<EFBFBD>O<EFBFBD>$5<><13><19><19><1B>$D<>D<><12>s<00>?Ac3<01><><00>K<00>|]J\}}}|dk(r4t<00><05><02>n<00><05><04><00>j<00>|j<00>k(n|<01>|<02><00><01><00>Ly<01>wr<>ri)r<><00>op_fnr<6E>r r<>r<>r<>s <20><><EFBFBD>rr<>z0SpecifierSet._filter_versions.<locals>.<genexpr><3E>s\<00><><00><><00><0E>#<23>E<EFBFBD>3<EFBFBD><02><16><15>;<3B><14>C<EFBFBD>K<EFBFBD>D<EFBFBD>S<EFBFBD><14>Y<EFBFBD>7<>=<3D>=<3D>?<3F>3<EFBFBD>9<EFBFBD>9<EFBFBD>;<3B>N<><1A>6<EFBFBD>3<EFBFBD>'<27>(<28><0E>s<00>AA)r<>r<>r<>r<>r<>r<>r<>)rCr<>r<>r<><00>ops<70>exclude_prereleasesr<73>r<>s ` @@rr<>zSpecifierSet._filter_versionsks<><00><><00><><00> <10> <1D> <1D> %<25>!'<27><12> $<24> <0B> <0B><12>#<23> "<0E>D<EFBFBD> <1E><13> <20> <20><03>)<29>U<EFBFBD>2<><1B><1C> <1B>D<EFBFBD>$<24>S<EFBFBD>[<5B>T<EFBFBD>c<EFBFBD>$<24>i<EFBFBD>H<>F<EFBFBD><15>~<7E><16><12>&)<29><12><12><1F>J<EFBFBD>$<24><16>)=<3D>)=<3D><14><14><0E>'*<2A> <0E><0E><1B>
<EFBFBD>' <1B>s<00>A4B,<01>:*B,<01>%B,rz)r<>zstr | Iterable[Specifier]r<>r<>r^r_)r^ztuple[Specifier, ...]r<>r)r^z)tuple[tuple[Specifier, ...], bool | None]r<>rdrb)rJzSpecifierSet | strr^rr`)r^zIterator[Specifier]r|)r^r()r<>r<>r^r(r<>)r<>r<>r<>r<>r<>r<>r^r(r<>r<>r<>r<>r)r<>r<>r<>r<>r<>r<>r^r<>)r5r6r7r8rerEr<>r<>r<>r<>rr(r]r<>rWr<>rPr<>r<>r<>r<>r<>r<>rnr<>r<>r<>r<>r<>rrrrr6s<><00><00><08>$<06>I<EFBFBD>13<31>#'<27>+3<>-<2D>+3<>!<21>+3<>
<0E> +3<>Z<1B><0E><14><0E><14>&<11><17><17>&<26><18>&<26>0<> 7G<01>rB<01>* A<01>-<2D><19>BC<01>4 <20>!<21><16>,<16>B <14>%@<01>N#<23>0$(<28>!%<25> +N<01><1D>+N<01>!<21>+N<01><1F> +N<01>
<0E> +N<01>Z <0C>_<EFBFBD>_<EFBFBD>$(<28><17> +<2B>.<2E>+<2B>!<21>+<2B><12> +<2B>
&<26> +<2B><15>+<2B> <0C>_<EFBFBD>_<EFBFBD>$(<28>.1<EFBFBD> <1A><1D><1A>!<21><1A>,<2C> <1A>
<15> <1A><15><1A>$(<28>7;<3B> ^9<><1F>^9<>!<21>^9<>5<> ^9<>
<17> ^9<>H$(<28> ,<1B><1F>,<1B>5<>,<1B>!<21> ,<1B>
<17> ,rr)r^<00> list[str])r%rar^zTypeGuard[tuple[str, str]])r)rar^zTypeGuard[bool | None])r0<00>tuple[int, ...]r^r)r<>rgr<>r<>r^r()r<>r}r<>r}r^r~)rArr^r)rAr<>r^r{)rKr~r^r{)r<>r<>r<>r<>r^r<>)rAr$r^r)r<>rr^r$)r<>r$r^r()r<>rr^rc)r<>rr<>rcr^r)r<>z!tuple[CallableOperator, str, str]r^rc)Lr8<00>
__future__rr<>r9<00> functoolsrDr<><00>sysr<73>rrrrrr r
r r <00>utilsrrArr<00> version_infor<00>typing_extensionsrrr&r*r+r$r<>r,r(r<>r.r<>r2<00>Enumr4<00>total_orderingr>rgr<>r~r"<00> _VersionRangerrr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rr<00>ABCMetarrr<>r<>r<>rGrBrFrMrSr<>rrrr<00><module>rsr<00><01><04>#<23>
<EFBFBD> <0B><10><10> <09>
<EFBFBD> <0A>
<02>
<02>
<02>(<28>,<2C><06><13><13>w<EFBFBD><1E> <20><12>+<2B> <02><07><13><06>0<> <0C>C<EFBFBD>L<EFBFBD><01><17><07><13> <0C>%<25><0F><1C>1<><1F>I<><12><1B>W<EFBFBD>c<EFBFBD>N<EFBFBD>D<EFBFBD>0<>1<><10> '<27>x<EFBFBD>0<> <0C>n<EFBFBD>0<>=<3D><1E>D<EFBFBD>I<EFBFBD>I<EFBFBD><1E> <0B><19><19>;Q<01>;Q<01><1A>;Q<01>| <0B><19><19>%H<01>%H<01><1A>%H<01>P <0B><19><19>%H<01>%H<01><1A>%H<01>P
<EFBFBD><17><17><1E>w<EFBFBD>(8<>$<24>><3E>?<3F><16><1A>+<2B>{<7B>2<>3<>M<EFBFBD> <16>t<EFBFBD>U<EFBFBD> #<23><08> <16>t<EFBFBD>U<EFBFBD> #<23><08>&.<2E><08>%9<>$;<3B> <0B> !<21>;<3B>)<29><12>
!<21><12> "<22><12><19><12>4K<01> S<01>
<13>+<2B> @<01>2<>9<><19>9<><13>9<>* <08>z<EFBFBD> <08>O <0C>c<EFBFBD>k<EFBFBD>k<EFBFBD>O <0C>dr ,<2C> <0A>r ,<2C>j<1B><02>
<EFBFBD>
<EFBFBD>:<3A>;<3B> <0A>' <20><1B>' <20>"I<>' <20><12>' <20>T<12>,'<27><06> <11> O<01>2<>6a <1B>=<3D>a r
Reference in a new issue Copy permalink