+ yjnDzRt^RIHt^RIt^RIt^RIHtHtHtHt^RI H t H t H t H t HtHtHtHtHtHtHtHtHtHtHtHt^RIHt]'d^RIHtHtHtH t ^RI H!t!^RI"H#t#R .t$]!R 4t%]]]&3,t']!R ]'R 7t(^t)!R R]PT4t+RRlt,RRlt-RRlt.RRlt/RRlt0RRlt1RRlt2RRlt3RR lt4R!R"lt5R#R$lt6R%R&lt7R'R(lt8R)R*lt9R+R,lt:R-R.lt;R/R0ltR5R6lt?])3R7R8llt@R9R:ltAR;R<ltBR=R>ltC!R?R 4tDR#)@a Public :class:`VersionRange` API. A set-algebra view of the versions accepted by a :class:`~packaging.specifiers.SpecifierSet`. Ranges support intersection, union, complement, and difference; membership and filtering match the originating specifier set; and conversion back to a :class:`~packaging.specifiers.SpecifierSet` is available where a PEP 440 form exists. .. testsetup:: from packaging.ranges import VersionRange from packaging.specifiers import SpecifierSet from packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyTypeVarUnion) FULL_RANGE MIN_VERSIONNEG_INFPOS_INF BoundaryKindBoundaryVersion LowerBound UpperBoundcoerce_versionfilter_by_rangesintersect_rangesleast_version_abovematches_bounds_onlyrange_is_emptyranges_are_prerelease_only trim_release)Version)CallableIterableIteratorSequence)Interval) SpecifierSet VersionRangeTUnparsedVersionVar)boundc]tRt^KtRt]P !4t]P !4t]P !4t Rt R#)_SetOpzNThe binary set operation ``_combine_literals`` resolves over ``===`` literals.N) __name__ __module__ __qualname____firstlineno____doc__enumauto INTERSECTIONUNION DIFFERENCE__static_attributes__r$D/var/www/html/2rare/lib/python3.14/site-packages/packaging/ranges.pyr#r#Ks&X99;L IIKEJr0r#cV^8dQhRR/#)returnz list[str]r$)formats"r1 __annotate__r6Ssr0c\#N)__all__r$r0r1__dir__r:Ss Nr0c$V^8dQhRRRRRR/#)r3leftSequence[Interval]rightr4list[Interval]r$)r5s"r1r6r6\s&44 4 44r0cV'g \V4#V'g \V4#.p^;r4V\V48dvV\V48dfW,^,W,^,8:d#VPW,4V^, pKcVPW,4V^, pKVPWR4VPWR4V^,.pVR,EFwrgVR,wrV Pe*VPeV PVP8dRp MV PVP8Xd"V P ;'g VP p MU\ V PV P '*4p \VPVP '*4p \W4p V 'dV\W43VR&KVPWg34EK V#)zUnion two sorted, non-overlapping interval lists. A linear merge over the two pre-sorted inputs followed by a single coalescing pass: adjacent or overlapping intervals collapse so the result is itself sorted and non-overlapping. NNNT) listlenappendextendversion inclusiver rrmax) r<r> merged_input left_index right_indexmergedlowerupper prev_lower prev_upperoverlaps gap_lower gap_uppers && r1 _union_rangesrV\s E{ Dz#%L  J s4y [3u:%=  A %"4Q"7 7    0 1 !OJ    2 3 1 K[)*l+,*1o.F$R(( !'     &}}$!!EMM1H   5== 0!++>>uH #:#5#5:;O;O7OPI"5==eoo2EFI%i;H $c*&<=F2J MM5. )-)0 Mr0c V^8dQhRRRR/#)r3rangesr=r4r?r$)r5s"r1r6r6s%%1%n%r0cLV'g\\4#.pRpVFwr4VfLVPe=\VPVP'*4pVP \ V34M\\VPVP'*4p\VPVP'*4pVP We34TpK VfQhVPe=\VPVP'*4pVP V\34V#)zComplement a sorted, non-overlapping interval list. Yields the gaps between intervals plus a leading gap before the first and a trailing gap after the last. Bound inclusivity flips so that complement-of-complement round-trips back to the input. N) rDrrHrrIrFr r r )rXresultrRrOrPrUrTs& r1_complement_rangesr[s JF$(J    }}(&u}}%//6IJ  w 23":#5#5:;O;O7OPI"5==eoo2EFI MM90 1 !&  !! !%z11z7K7K3KL  y'*+ Mr0c V^8dQhRRRR/#r3boundstuple[Interval, ...]r4r$)r5s"r1r6r6s16Jr0c"V'gV#V^,wr\\V4'd VR,#VP'dI\VP\ 4'd)VP\ 8:d\V3.VR,O5#V#)aQCollapse the PEP 440 floor in a sorted interval list. Only the first interval can touch ``0.dev0`` (the minimum version). An inclusive lower at or below it admits everything below, the same as ``-inf``, so ``>=0.dev0`` becomes the one canonical full range. An exclusive upper at or below it leaves the interval empty, so it is dropped. rA)rr rI isinstancerHrr)r^rOrPs& r1_canonical_floorrbsr  !9LEgu%%bz  u}}g . . MM[ (% .6":.. Mr0c V^8dQhRRRR/#)r3rHrr4zBoundaryVersion | Noner$)r5s"r1r6r6s&&7&/E&r0cVPfR#RpVPeiVP^8XdXVPfJVPwr#V^8d4\VP W#^, 3RR7\ P 4pMVP^8d=\VP VP^, R7\ P4pMVP^8XdqVPecVP^8XdVP RRR7M#VP VP^, RR7p\V\ P4pVe\V4V8XdV#R#)aThe boundary whose least successor is *version*, or ``None``. Inverse of :func:`~packaging._ranges.least_version_above`. A plain version that is exactly such a successor (``1.0a2.dev0`` sits just above ``AFTER_POSTS(1.0a1)``) folds back to that boundary, so ``>=1.0a2.dev0`` and ``>1.0a1`` share one form. The proposed boundary is confirmed by round-tripping through ``least_version_above``. N)predevrfpostrf) rfrerir __replace__r AFTER_POSTS AFTER_LOCALSr)rH candidatekindnumberbases& r1_predecessor_boundaryrqs8{{(,I{{7;;!#3 8L{{  Q;'##z(:#E((I  #   GKK!O  4l6O6O   gll6||q    Tt  4$$',,*:$E $D,*C*CD !4Y!?7!J r0c V^8dQhRRRR/#r]r$)r5s"r1r6r6s.3Gr0c.pVFwr#Y#rT\VP\4'd9VP'd'\ VP4pVe\ VRR7p\VP\4'd9VP'g'\ VP4pVe\ VRR7pVPWE34K \V4#)aFold least-successor bounds to their boundary form. ``>=1.0a2.dev0`` and ``>1.0a1`` denote the same set, so both must reduce to one representation for ``==`` and ``hash`` to agree. An inclusive lower or exclusive upper sitting on a boundary's least successor becomes that boundary; the engine's emptiness check has already dropped the synthetic gaps such intervals would otherwise leave. FrIT) rarHrrIrqr rrFtuple)r^rZrOrP new_lower new_upperboundarys& r1 _canonicalizerys F $9 emmW - -%///,U]];H#&x5A emmW - -eooo,U]];H#&x4@  y,- =r0c(V^8dQhRRRRRRRR/#)r3r^r_admit_arbitraryboolliteralstrr4r$)r5s"r1r6r6s, / /  /37 /BE /  /r0c\\V4pVfT;'d V\8H#\W4#)aTrue when the bounds (plus arbitrary admission) admit ``literal``. Skips the explicit admit/reject sets, which the caller layers on top. A non-version string matches via ``admit_arbitrary`` only on full bounds; on narrower bounds the flag is metadata only. )rrr)r^r{r}parseds&&& r1_struct_admitsrs1G $F ~776Z#77 v ..r0c V^8dQhRRRR/#)r3valuezBoundaryVersion | Versionr4r~r$)r5s"r1r6r6+s7Cr0c\V\4'd'VP RVPP R2#\ V4#)z?Printout for a bound's inner value, kind-tagged for boundaries.[])rar rHrnnamer~)rs&r1_bound_version_strr+s9%))--%**//!2!44 u:r0c V^8dQhRRRR/#)r3r!r r4r~r$)r5s"r1r6r62;;;;r0cVPfR#VP'dRMRpV \VP4 2#)Nz(-infr(rHrIrr!brackets& r1 _format_lowerr2s8 }}___c#GY)%--89 ::r0c V^8dQhRRRR/#)r3r!rr4r~r$)r5s"r1r6r69rr0cVPfR#VP'dRMRp\VP4 V 2#)Nz+inf)r)rrs& r1 _format_upperr9s7 }}___c#G / 0 ::r0c V^8dQhRRRR/#)r3 intervalsr=r4r~r$)r5s"r1r6r6@s!3r0c2RPRV44#)zARender a sorted interval list as ``lower, upper | lower, upper``. | c3X"TF wr\V4 R\V4 2xK" R#5i), N)rr).0rOrPs& r1 $_format_intervals..Bs,NWle=  =#7"89is(*)join)rs&r1_format_intervalsr@s ::NW r0c V^8dQhRRRR/#)r3rHrr4r|r$)r5s"r1r6r6Rsg$r0cVP^8H;'d;VPRJ;'d%VPRJ;'dVPRJ#)zFTrue when version is exactly ``X[.Y]*.dev0`` (the shape ``rhepochrelease!=.*>=rC) rfrerrirjrrr from_partsrany)rHfamilylast below_releasebelows& r1 _clean_lowerr\s{{a7;;2gmm6O|| <0 zero-family floor. An epoch>0 zero-family base such as ``1!0.dev0`` has no ``>=P,!=P.*`` spelling since no version sorts below ``E!0`` within the epoch. While the interval stays within ``==E!0.*`` it is that wildcard, trimmed by the upper and with a leading ``.dev`` run excluded: an ``AFTER_LOCALS(E!0.dev(k))`` lower drops ``E!0.dev0..E!0.dev(k)``, a plain inclusive ``E!0.dev0`` lower drops none. Returns the ``E!0`` family, how many leading ``.dev`` releases to exclude, and whether the upper sits at the family cap (so ``==E!0.*`` needs no upper), else ``None``. N)rrrfFr)rB)rHrar rnr rlrfrrIrrerirrrrrr)rOrPrH excluded_devs next_familycaprs&& r1_epoch_floor_lowerrsmmG'?++ <<<44 4// ;;  a GW % %%/// ;;!  }}{{',,":gmm>W < ())$$7==$ANK [% (C {   gmmT BF %, ..r0c V^8dQhRRRR/#)r3rrr4rr$)r5s"r1r6r6sw+;r0cV\8:d.#\V4pVeV#VPf/VP^8XdVP RRR7pRV 2RV 2.#R#)a2Prerelease-free fragments for ``[family, ..)``, or ``None`` if it has none. ``family`` is an ``X.dev0``. The floor gives ``[]`` (every version); a release base its ``_clean_lower`` family-floor spelling (``!=0.*`` ...); an ``X.post0`` base ``>=X,!=X``. A pre-release base has no prerelease-free spelling. Nrhrr)rrrerirj)rcleanrps& r1_dev_family_anchorrsj  E   zzfkkQ.!!t!6TF r$[)) r0c$V^8dQhRRRRRR/#)r3rOr keep_dev0r|r4rr$)r5s"r1r6r6s">">">">"9I>"r0cVPpVf.#\V\4'EdVP\P 8XdRVP 2.#VPpV\ 8:dRV 2.#V'gVPeVP^R7p\V4pVeeVP^,\8dR#\VP^,4Uu.uFpRVPVR7 2NK ppWW,#M"\V4pVe \V4MRp V eV #RV 2RV 2.#VP'gR#V'g\V4p V eV #RV 2.#uupi)aEncode a lower bound as specifier fragments, or ``None``. ``[]`` for ``-inf``. An ``AFTER_POSTS(V)`` lower is ``>V``. An ``AFTER_LOCALS(V)`` lower is the set ``[successor, ..)`` and emits ``>=V,!=V``, except in the prerelease-free spelling mode (``keep_dev0`` false), where it recovers a spelling with no synthetic ``.dev0`` when one exists: ``>3.8.post1`` for a post release, or a dev family's anchor plus the dev run up to V for a ``.dev`` release. Nrrrgr)rHrar rnr rkrrfrjr_MAX_EXCLUSION_RUNrangerrrI) rOr lower_versioninnerranchordrun successorrs && r1 _encode_lowerrsMMM -11   !9!9 9 --./0 0%% K L> !yy$ **q*1+F3%yy1}'99#BG TU BVBVQ"V//A/678BV"<' &0 > 3<3H Y/d$ L UG 5'l++ ??? ]+  L !!3s)E1c$V^8dQhRRRRRR/#)r3rPrrr|r4rr$)r5s"r1r6r6s"22229I2r0crVPpVf.#\V\4'dVP\P 8XdlVPpV'gRVP fDVPe6VPf(RVPVP^,R7 2.#RV 2.#\V4pVeRV 2.#R#VP'g\VP^8XdAVP f3VPf%V'gRVPRR7 2.#RV 2.#RV 2RV 2.#R#)a Encode an upper bound as specifier fragments, or ``None``. ``[]`` for ``+inf``. In the prerelease-free spelling mode (``keep_dev0`` false) the ``-BCDEEL> !( 6   {O$ $ ???    "!!)##+M55$5?@ABB '( (]O$=/&:;; r0c$V^8dQhRRRRRR/#)r3rOr rPrr4zVersion | Noner$)r5s"r1r6r68s&FF*FZFNFr0c\VP\4'g!\VP\4'dR#VPeVPfR#VP'dVP'dR#\ VP4'd\ VP4'gR#VPP VPP 8wdR#\ VPP4p\ VPP4p\\V4\V44pV^8gQhVRV\V4, ,, pVRV\V4, ,, pVRRVRR8wdR#VR,VR,^,8wdR#VPPVRR7#)z;If ``[lower, upper)`` is the ``==V.*`` shape, return ``V``.N)rrfrrC) rarHr rIrrrrrJrErj)rOrP lower_release upper_release padded_lengths&& r1_detect_equal_wildcardr8sd%--11Z 66 }} 5 ???eooo U]] + +0@0O0O }}emm111 !6!67M !6!67MM*C ,>?M 1  T]S-??@@MT]S-??@@MSb]3B// RM"-11 == $ $] $ EEr0c(V^8dQhRRRRRRRR/#) r3rOr rPrrr|r4rr$)r5s"r1r6r6Zs2A%A% A%(A%59A%A%r0ca VPeVPe\VP\4'g\VP\4'ghVP'dVVP'dDVPVP8Xd)VPPeRVP 2.#\VP\ 4'dVP'dVP'd\VP\4'd_VPP \P8Xd6VPPVP8XdRVP 2.#\W4pVeRV R2.#V'g \W4MRpVejVwo rVV\8dR#RS R2.pVPV 3Rl\V444V'g#\W4pVfR#VPV4V#\W4p V fR#\W4pVfR#W,#)a Encode one interval as specifier fragments, or ``None``. Special-cases the ``==V`` singleton (``[V, AFTER_LOCALS(V)]`` for a plain ``V``, and ``[V+local, V+local]`` for a local one) and the ``==V.*`` shape so the fragment is one equality rather than a bound pair. Nz==rc3N<"TFpRSPVR7 2xK R#5irrgNrj)rrrs& r1r#_encode_interval..s)T?S!r&,,,345?S"%)rHrar rIrrrnr rlrrrrGrrr) rOrPrwildcardfloorr upper_at_capparts upper_parts lower_partsrs &&& @r1_encode_intervalrZs  ! MM %5==/::5==/:: OOO OOO MMU]] * MM   +U]]O$%% 5=='** OOO OOO u}}o 6 6 MM  ,";"; ; MM ! !U]] 2U]]O$%%%e3HXJb!""5> u ,4E .3+ - -fXR! Tu]?STT'9K" LL % 1K1K  $$r0c$V^8dQhRRRRRR/#)r3 left_upperr right_lowerr r4list[Version] | Noner$)r5s"r1r6r6s$:::)3::r0ca\VP\4'd\VP4pVfR#M.VPeVP'dR#VPp\VP\4'gEVPe5VP'g#VPV8XdVP eV.#R#VPP \P8wdR#VPPpW#8XdV.#\\V\P44oSeSPeVPeVPSP8dVPSPR7S8XdfVPSP, ^,\8dR#V3Rl\SPVP^,44pV.VO#R#)aIf the gap between two intervals is a ``!=V`` chain, list its points. A plain exclusive left upper names the first excluded V directly; an inclusive boundary left upper names it via its least successor. Adjacent exclusions (``V`` and its immediate successors) share a single gap spanning a contiguous dev run, so one gap can name a short chain: ``!=1.0,!=1.0.post0.dev0`` is one gap from ``1.0`` up to ``AFTER_LOCALS(1.0.post0.dev0)``. Nrgc3H<"TFpSPVR7xK R#5i)rgNr)rrseconds& r1r$_detect_not_equal..s$R2QQv!!a!((2Qs") rarHr rrIrrnr rlrfrjrr)rrfirstrrrs&& @r1_detect_not_equalrs*$$o66$J$6$67 =     #z';';';"" k))? ; ;    +)))##u, '7N<#<#<<    & &D }w! 8Q8Q!R SF JJ " HH HH "     , 6 88fjj 1 $'9 9R% DHHqL2QR}} r0c ,V^8dQhRRRRRRRRRR/#) r3 lower_trimztuple[int, ...] upper_trimrintbudgetr4rr$)r5s"r1r6r6s:2222 2  2  2r0c *^pV\V48d/V\V48dW,W,8Xd V^, pK>\V4V^,8dR#VRVp\V4V8d W,M^pW,pWv, pW8dR#\Wg4U u.uF p \P!V.VOV N5R7NK" p p \V4V^,8XdV #\ .VOVN5WV\ V^4, 4p V fR#W,#uup i)aDecompose the gap ``[L.dev0, U.dev0)`` into wildcard prefixes. ``lower_trim``/``upper_trim`` are trimmed release tuples with ``lower_trim < upper_trim`` lexicographically. The chain sweeps at the first differing level. The gap is undecomposable when L has trailing components below that level (the chain cannot escape L's subtree), or when the chain, summed across levels, would exceed ``budget`` prefixes. Nr)rErrr_decompose_dev0_gaprJ) rrrrdiffcommon lower_val upper_valspansegment fragmentstails &&&& r1rrs D s: 3z? "   0 0   :!  F$' Od$:  I I  D }Y22G 0B&0B'0BC2  :$(" &)j#dA,1F D |  #s&Dc$V^8dQhRRRRRR/#)r3rrrr r4rr$)r5s"r1r6r6s'@@J@Z@DT@r0c@a \W4pVeVUu.uFpRV 2NK up#VPp\V\4'd$VP'g\ V4'gR#VPp\V\4'dVP'd Vo ^p\ pM\V\4'dVP\P8Xd~VP'glVPpVPeVP^,\ 8dR#VP^R7o VP^,p\ V, pMR#\ S 4'gR#VPS P8wgVS 8dR#\\VP 4\S P 4VPV4p V fR#V U u.uF p RV R2NK p p V P#V 3Rl\%V444V #uupiuup i)a'Encode the gap between two adjacent intervals as ``!=`` fragments. A point chain becomes ``!=V`` fragments and a dev0 family span becomes ``!=P.*`` prefixes, followed by a leading dev run in the last family when the gap ends inside it. Any other gap has no exclusion form and returns ``None``. Nrrgrc3N<"TFpRSPVR7 2xK R#5irr)rr upper_dev0s& r1r_encode_gap..Rs)VDUq:11a189:DUr)rrHrarrIrrr rnr rlrfrjrrrrrGr) rrpointspointleft_vright_v run_lengthrrPprefixesprefix exclusionsrs && @r1 _encode_gapr sz 7F *01&"UG &11  F vw ' '    ''!!G'7## (=(=(=  #7O,, LLL55 5%%%  99  A 0B B&&1&- YY] #j0 J ' ' ||z'''6Z+?"V^^$Z''(  H 089fBvhb/J9VE*DUVV i2d:s HHc V^8dQhRRRR/#)r3r^r=r4rr$)r5s"r1r6r6Vs+0@r0c.p\^\V44FHp\W^, ,^,W,^,4pVfR#VPV4KJ V#)ahEncode every between-interval gap as ``!=`` fragments, or ``None``. When each gap has an exclusion spelling, the intervals fuse into one contiguous span (``==1.* | ==3.*`` is ``!=0.*,!=2.*,<4``): the outer interval across all the bounds plus these exclusions. A gap with no exclusion spelling makes the bounds a disjoint union, which no single set expresses. N)rrEr rG)r^r indexgaps& r1 _encode_gapsrVs[Jq#f+&&+A. a0@A ;# ' r0c V^8dQhRRRR/#r]r$)r5s"r1r6r6js$8=Qr0cVR,wrVPp\V\4'd[VP'gIVP'g7VP f)\ VP^R7RR7p.VRROW3N5#V#)aSnap the range's final upper out of the pre-release band ``False`` drops. An exclusive upper at a final ``V`` admits the versions in ``[V.dev0, V)`` at the bounds level, but a ``prereleases=False`` policy filters them all out, so it accepts the same releases as ``R?ltR@RAltRBRClt RDRElt!]"PFR`RFRGll4t$]"PFR`RHRIll4t$RaRJRKllt$RLRMlt%]RNROl4t&RPRQlt'](RRRSl4t)RaRTRUllt*RVRWlt+RXRYlt,RZR[lt-R\R]lt.R^t/R#)briaOA set of :class:`~packaging.version.Version` values accepted by a :class:`~packaging.specifiers.SpecifierSet`. Construct via :meth:`~packaging.specifiers.SpecifierSet.to_range`, or with the :meth:`full`, :meth:`empty`, and :meth:`singleton` class methods. Compose with :meth:`intersection`, :meth:`union`, :meth:`complement`, and :meth:`difference` (or the ``&`` / ``|`` / ``~`` / ``-`` operators). Test membership with ``in`` or :meth:`contains`, filter an iterable with :meth:`filter`, and convert back to a :class:`~packaging.specifiers.SpecifierSet` with :meth:`to_specifier_set`. The configured pre-release policy of the originating specifier set carries onto the range and controls whether pre-releases are admitted under ``in``, :meth:`contains`, and :meth:`filter`. With no configured policy, :meth:`filter` also admits pre-releases in the autodetected opt-in region (the versions a pre-release-naming specifier asked for). Set algebra keeps that opt-in scoped to those versions, so unrelated pre-releases are not admitted wholesale. :meth:`intersection`, :meth:`union`, :meth:`difference`, and the :meth:`is_subset` / :meth:`is_superset` / :meth:`is_disjoint` predicates require both operands to share the same configured policy. >>> r = SpecifierSet(">=1.0,<2.0").to_range() >>> "1.5" in r True >>> "2.0" in r False >>> SpecifierSet(">=2.0,<1.0").to_range().is_empty True PEP 440's ``===`` operator matches a candidate string verbatim (case-insensitive) rather than a set of versions. Ranges built from ``===`` specifiers still support membership, set operations, and conversion back to a :class:`~packaging.specifiers.SpecifierSet`; matching follows the literal-equality rule. A ``===`` literal that names a pre-release is admitted under the default policy by both :meth:`contains` and :meth:`filter`, since it was named outright. .. versionadded:: 26.3 _admit_admit_arbitrary_bounds _pre_region_prereleases_configured_rejectr_r|frozenset[str] bool | Nonec$V^8dQhRRRRRR/#)r3argsobjectkwargsr4rr$)r5s"r1r6VersionRange.__annotate__s!  F f  r0c \R4h)zcannot create 'VersionRange' instances directly; use SpecifierSet.to_range(), VersionRange.full(), VersionRange.empty(), or VersionRange.singleton() instead) TypeError)clsr r"s&*,r1__new__VersionRange.__new__s H  r0F pre_regionprereleases_configuredNc4V^8dQhRRRRRRRRRRR R R R /#) r3r^r_admitrrejectr{r|r)r*rr4rr$)r5s"r1r6r#sP66$66 6  6)6!,6 6r0c aa\S4oV'dV'd W#, pV'd\VV3RlV44pV'd\VV3RlV44p\PV4pSVnW'nW7nSVnWgnVf V'g RVn V#\\\V4S44Vn V#)aInternal factory; bypasses :meth:`__new__`. Canonicalizes the bounds so equal version sets share one representation, then drops admit literals the bounds already admit and reject literals the bounds do not match anyway. Reject wins over admit on overlap. The pre-release policy is set here and never reassigned afterwards; ``pre_region`` is canonicalized like the bounds and clipped to them, or dropped when a configured policy makes it inert. c3R<"TFp\SSV4'dKVxK R#5ir8rrr}r{r^s& r1r&VersionRange._build..s&$G%fowG$' 'c3R<"TFp\SSV4'gKVxK R#5ir8r0r1s& r1rr2 s&%G!&/7C%r3r$) ry frozensetr!r'rrrrrrrur)r&r^r,r-r{r)r*instances&f&&f$$ r1_buildVersionRange._builds(v& VNE $E %F >>#&!!$3!+A( " -Z#%H  $) z!:FC$H r0cV^8dQhRR/#r3r4r|r$)r5s"r1r6r#%s77t7r0c f\VP4;'g\VP4#r8)r|rrselfs&r1 _has_literalsVersionRange._has_literals%s"DKK 66D$66r0cV^8dQhRR/#r:r$)r5s"r1r6r#(sDD4Dr0c PVP;'dVP\8H#)aKTrue when ``_admit_arbitrary`` actually admits non-version strings. The flag rides through set algebra but only fires admission on full bounds. Intersection and difference drop it when the bounds shrink, so away from full bounds it survives only on empty-bounds ranges, where it keeps ``~~full() == full()`` and union idempotent. )rrrr<s&r1_arbitrary_activeVersionRange._arbitrary_active(s!$$CC)CCr0cV^8dQhRR/#r:r$)r5s"r1r6r#2s  4 r0c VP4'*;'d(VP'*;'dVPRJ#)zTrue when membership is decided by ``_bounds`` alone, enabling the bounds-only fast paths in :meth:`is_subset` and :meth:`is_disjoint`. F)r>rrr<s&r1 _is_plainVersionRange._is_plain2sF ""$ $ : :))) : :,,E9 r0c V^8dQhRRRR/#)r3otherrr4Noner$)r5s"r1r6r#<s  , 4 r0c \V\4'g"\R\V4P 24hVP VP 8wd(\ RVP : RVP : 24hR#)z{{ LL++<< 11!#-   r0 prereleasesc V^8dQhRRRR/#)r3r[rr4rr$)r5s"r1r6r#gsBB;B,Br0c (VPRVR7#)zReturn the empty range. No version satisfies it. >>> VersionRange.empty().is_empty True >>> "1.0" in VersionRange.empty() False r*r$)r7)r&r[s&$r1emptyVersionRange.emptyfszz"[zAAr0r{Tc$V^8dQhRRRRRR/#)r3r{r|r[rr4rr$)r5s"r1r6r#rs$  !% ;F  r0c 2VP\VVR7#)aReturn the full range. Every PEP 440 version satisfies it. ``admit_arbitrary=False`` restricts the range to PEP 440 versions only (matching the same versions as ``SpecifierSet(">=0.dev0").to_range()``); its complement is :meth:`empty`. The flag propagates through set algebra and is part of equality. Default ``True`` so that ``r & full()`` preserves ``r``'s own flag structurally. >>> "1.0" in VersionRange.full() True >>> "wat" in VersionRange.full() True >>> "wat" in VersionRange.full(admit_arbitrary=False) False )r{r*)r7r)r&r{r[s&$$r1fullVersionRange.fullqs#&zz +#.  r0c$V^8dQhRRRRRR/#)r3rH Version | strr[rr4rr$)r5s"r1r6r#s$  # 5@  r0c \V\4'g \V4p\VR4p\VR4pVP \ W4334VR7#)aReturn the strict singleton range ``{version}``. Built as the closed interval ``[version, version]`` with strict equality. ``Specifier("==V")`` matches ``V+local`` too, so the strict singleton is narrower: >>> "1.0+local" in VersionRange.singleton("1.0") False >>> "1.0+local" in SpecifierSet("==1.0").to_range() True :raises packaging.version.InvalidVersion: if version is a string that does not parse as a PEP 440 version. Tr^)rarr rr7rb)r&rHr[rOrPs&&$ r1 singletonVersionRange.singletons[$'7++g&G7D)7D)zz un. /#.  r0c V^8dQhRRRR/#r3rIrr4r$)r5s"r1r6r#s' ' ,' <' r0c  VPV4VPp\\VPVP44pVP V4pVP ;'d VP ;'d \V4pVP4'g,VP4'gVPVVVVR7#VPVV\PVVVR7#)a=Range containing exactly the versions in both self and other. Both operands must share the same configured pre-release policy; otherwise :exc:`ValueError` is raised. >>> a = SpecifierSet(">=1.0").to_range() >>> b = SpecifierSet("<2.0").to_range() >>> a.intersection(b) == SpecifierSet(">=1.0,<2.0").to_range() True r{r)r*opr{r)r*) rOrrurrrSrr|r>r7_combine_literalsr#r,r=rIrV new_bounds new_region combined_arbs&& r1 intersectionVersionRange.intersections !!%(11 +DLL%--HI ((/  ! ! Q Qe&<&< Q QjAQ !!##E,?,?,A,A;; ,%'1  %%  ""(!#- &  r0c V^8dQhRRRR/#rkr$)r5s"r1r6r#s- - <- L- r0c  VPV4VPp\\VPVP44pVP V4pV'd\VP ;'d\VP4;'g*VP ;'d\VP4pM VP ;'g VP pVP4'g,VP4'gVPVVVVR7#VPVV\PVVVR7#)a:Range containing every version in self or other. Both operands must share the same configured pre-release policy; otherwise :exc:`ValueError` is raised. >>> a = VersionRange.singleton("1.0") >>> b = VersionRange.singleton("2.0") >>> "1.0" in a.union(b) and "2.0" in a.union(b) True >>> "1.5" in a.union(b) False rmrn) rOrrurVrrSrr|r>r7rpr#r-rqs&& r1unionVersionRange.unions !!%(11 =u}}EF ((/  11HHd4<<6H&&>>4 +>   00JJE4J4JL!!##E,?,?,A,A;; ,%'1  %%  ||(!#- &  r0cV^8dQhRR/#r3r4rr$)r5s"r1r6r#s   L  r0c  VP\\VP44VPVP VP RVPR7#)alRange containing every version not in self. Preserves the configured pre-release policy. On the version set, double negation holds for a range with no ``===`` literals (the arbitrary-string flag round-trips, so ``~~full() == full()``); for ``===`` ranges complement is one-way. The opt-in region is not restored (see below). The opt-in region is dropped: a complement is an exclusion, and an exclusion expresses no pre-release preference. This is what lets ``a & ~b`` shed ``b``'s opt-in, so an excluded ``b`` never force-admits a pre-release into the result. Complement stays involutive on the version set, but not on the opt-in region: ``~~r`` covers the same versions as ``r`` yet force-admits none of its pre-releases. >>> r = SpecifierSet(">=1.0").to_range() >>> "0.5" in r.complement() True >>> "1.5" in r.complement() False >>> r.complement().complement() == r True rXr$)r7rur[rrrrrr<s&r1 complementVersionRange.complementsO2{{ $T\\2 3,,;; 11#'#?#?   r0c V^8dQhRRRR/#rkr$)r5s"r1r6r##s? ? ? ? r0c  DVPV4VP'gVP'gV#\\ VP\ VP444pRpVP f VPpVP;'dW P8HpVP4'g6VP4'g VPVVVVP R7#VPVV\PVVVP R7#)aRange containing the versions in self but not in other. Matches ``self & ~other`` on the version set and the opt-in region; ``other`` acts as a bounds-only exclusion that grants no opt-in. The arbitrary-string flag survives only when ``other`` removed no versions: a difference that shrinks the bounds forgets it, as ``self & ~other`` would, so no later widening union can revive it. They still part on ``===`` literals, whose complement is one-way: a ``===`` literal stays when ``self`` admits it and ``other`` does not. Both operands must share the same configured pre-release policy (as :meth:`intersection` and :meth:`union` require); otherwise :exc:`ValueError` is raised. ``a - empty()`` returns a range equal to ``a``. >>> a = SpecifierSet(">=1.0").to_range() >>> b = SpecifierSet(">=2.0").to_range() >>> "1.5" in a.difference(b) True >>> "2.0" in a.difference(b) False >>> a.difference(VersionRange.empty()) == a True rmrnr$)rOrrrurr[rrrr>r7rpr#r.)r=rIrrrsrts&& r1 differenceVersionRange.difference#s. !!%(}}}U\\\K T\\+=emm+L M ,.  ' ' /))J ,,KK||1K !!##E,?,?,A,A;; ,%'+'C'C  %%    (!#'#?#? &  r0c4V^8dQhRRRRRRRRR RR R R R/#) r3rIrrrr_ror#r{r|r)r*rr4r$)r5s"r1r6r#dsP& & & )&  &  & )& !,&  & r0c  J\4p\4pVPVP,VP,VP,Fp VPV 4p VPV 4p V\P JdT ;'dT p M2V\P JdT ;'gT p MT ;'dV '*p V 'dVPV 4KVPV 4K VPV\V4\V4VVVR7#)zGResolve admit/reject for ``self`` ``op`` ``other`` over their literals.rX) setrr_matches_literalr#r,r-addr7r5) r=rIrrror{r)r*admitsrejectsr}self_inother_inwants &&&$$$$ r1rpVersionRange._combine_literalsds5E{{T\\1ELL@5==PPG++G4G--g6HV(((++8v||#**(//x< 7# G$Q {{ F#W%+!#9   r0c V^8dQhRRRR/#)r3r}r~r4r|r$)r5s"r1r6r#s 9 9 9 9r0c WP9dR#WP9dR#\V4pVfVP4#\ VP V4#)z=Whether literal (case-folded) matches this range's predicate.FT)rrrrBrr)r=r}rs&& r1rVersionRange._matches_literalsK ll " kk !( >))+ +"4<<88r0c V^8dQhRRRR/#r3rIr!r4rr$)r5s"r1r6r#s((V( (r0c \\V\4'g\#VPV4#)z(Operator alias for :meth:`intersection`.)rarNotImplementedrurNs&&r1__and__VersionRange.__and__s&%..! !  ''r0c V^8dQhRRRR/#rr$)r5s"r1r6r#s!!F!|!r0c \\V\4'g\#VPV4#)z!Operator alias for :meth:`union`.)rarrryrNs&&r1__or__VersionRange.__or__s$%..! !zz%  r0cV^8dQhRR/#r|r$)r5s"r1r6r#s!!L!r0c "VP4#)z&Operator alias for :meth:`complement`.)r~r<s&r1 __invert__VersionRange.__invert__s  r0c V^8dQhRRRR/#rr$)r5s"r1r6r#s&&V& &r0c \\V\4'g\#VPV4#)z&Operator alias for :meth:`difference`.)rarrrrNs&&r1__sub__VersionRange.__sub__s$%..! !u%%r0c V^8dQhRRRR/#r3rIrr4r|r$)r5s"r1r6r#s!/!/|!/!/r0c jVPV4VP4'dVP4'gR#VP4'dEVP4'd/\VP\ VP44'*#VP V4P#)aPReturn whether every member of self is also a member of other. On versions and ``===`` literals this is ``self.difference(other).is_empty``: subtracting other leaves nothing behind. A live arbitrary admission (the flag at full bounds) is only a subset of another live one. Both operands must share the same configured pre-release policy; otherwise :exc:`ValueError` is raised. >>> inner = SpecifierSet(">=1.5,<1.8").to_range() >>> outer = SpecifierSet(">=1.0,<2.0").to_range() >>> inner.is_subset(outer) True >>> outer.is_subset(inner) False >>> VersionRange.empty().is_subset(outer) True F)rOrBrFrrr[ris_emptyrNs&&r1 is_subsetVersionRange.is_subsets( !!%(  ! ! # #E,C,C,E,E >>   1 1' 6H6WXX Xu%...r0c V^8dQhRRRR/#rr$)r5s"r1r6r#s%%%$%r0c FVPV4VPV4#)akReturn whether every member of other is also a member of self. The mirror of :meth:`is_subset`: ``a.is_superset(b)`` is ``b.is_subset(a)``. Both operands must share the same configured pre-release policy; otherwise :exc:`ValueError` is raised. >>> outer = SpecifierSet(">=1.0,<2.0").to_range() >>> outer.is_superset(SpecifierSet(">=1.5,<1.8").to_range()) True )rOrrNs&&r1 is_supersetVersionRange.is_supersets! !!%(t$$r0c V^8dQhRRRR/#rr$)r5s"r1r6r#s111$1r0c VPV4VP4'd<VP4'd&\VPVP4'*#VP V4P #)apReturn whether self and other share no member. Equivalent to ``(self & other).is_empty``. Both operands must share the same configured pre-release policy; otherwise :exc:`ValueError` is raised. >>> a = SpecifierSet(">=1.0,<2.0").to_range() >>> a.is_disjoint(SpecifierSet(">=2.0,<3.0").to_range()) True >>> a.is_disjoint(SpecifierSet(">=1.5,<2.5").to_range()) False )rOrFrrrurrNs&&r1 is_disjointVersionRange.is_disjoints\ !!%( >>   1 1' emmDD D  '000r0c V^8dQhRRRR/#rr$)r5s"r1r6r#sSSLSTSr0c ~VPV4P;'dVPV4P#)aZWhether self and other admit the same non-pre-release versions. Used by :meth:`to_specifier_set` under a ``prereleases=False`` policy, where pre-releases are unobservable: the symmetric difference is empty exactly when the two ranges accept the same releases. Both operands carry that policy, so the difference below reads emptiness through it. )rrrNs&&r1_same_releasesVersionRange._same_releasess2u%..RR53C3CD3I3R3RRr0c(V^8dQhRRRRRRRR/#) r3iterablezIterable[UnparsedVersionVar]r[rkeyrJr4zIterator[UnparsedVersionVar]r$)r5s"r1r6r#s2++.+!+ + & +r0c R#r8r$r=rr[rs&&&&r1filterVersionRange.filters (+r0c(V^8dQhRRRRRRRR/#) r3rz Iterable[T]r[rrzCallable[[T], UnparsedVersion]r4z Iterator[T]r$)r5s"r1r6r# s2!,   r0c R#r8r$rs&&&&r1rr s r0c(V^8dQhRRRRRRRR/#) r3r Iterable[Any]r[rr%Callable[[Any], Version | str] | Noner4 Iterator[Any]r$)r5s"r1r6r#s2( ( ( !( 3 (  ( r0c hRpVfVPpVPpVP4pVP'gaVP'gOV'gGV'd(W@P 8Xd\ VP WR4#\ VP WW$4#VPWW%V4#)aYield items from iterable whose version falls inside the range. With prereleases ``None`` the PEP 440 default applies: pre-releases are buffered and only emitted if no final release in iterable is in range, except that a pre-release inside the autodetected opt-in region, or named outright by a ``===`` literal, is force-admitted in place (as ``prereleases=True`` would yield it). A flushed buffer comes after every in-place yield, so the output is not version-sorted. The signature mirrors :meth:`~packaging.specifiers.SpecifierSet.filter`. >>> r = SpecifierSet(">=1.0,<2.0").to_range() >>> list(r.filter(["0.9", "1.5", "2.0"])) ['1.5'] Tr$)rrrBrrrr_filter_with_admission)r=rr[rregionarbitrary_actives&&&& r1rrs,(*  66K%%F113{{{4<<<8H &LL0' hTJJ#DLL(U U** ;&  r0c 0V^8dQhRRRRRRRRR R R R /#) r3rrrrr[rrr|rr_r4rr$)r5s"r1r6r#;sNU$U$U$3U$! U$  U$ % U$ U$r0c# aaaaa"SPoSPoRVVVVV3RllpVRJd&VFpV!V4wpp V'gKVxK R#VRJd=VF4pV!V4wrp V'gKV eV P'dK0VxK6 R#.p .p Rp VFpV!V4wrpV'gKV f2V 'dVxM"V PV4V PV4KMV P'g+V 'gT RjxL V P 4Rp VxKV'gV'd\ WZ4'dVxKV 'dKV PV4K V 'g T RjxL R#R#LxL 5i)z~Filter for ranges with admit/reject literals or live arbitrary admission (including the universal ``SpecifierSet("")`` range).c V^8dQhRRRR/#)r3itemrr4z!tuple[bool, Version | None, bool]r$)r5s"r1r69VersionRange._filter_with_admission..__annotate__Hs ' ' ' A 'r0c<SfTMS!V4p\V4P4pS'd VS9dR#S'dVS9dR\V4R3#\V4pVfSRR3#\SPV4'gR#RVR3#)NFT)FNF)r~rOrrr) rraw raw_lowerr admit_setrr reject_setr=s & r1r,2VersionRange._filter_with_admission..admitHs),#d)CC(Ii:5))Y)3^C0$66#C(F~'u44&t||V<<))& &r0TNF)rrrrFclearr)r=rrr[rrr,rok_r all_nonfinalarbitrary_strings found_final by_literalrrsf&f&f& @@r1r#VersionRange._filter_with_admission;spKK \\  ' '" $   ;Aq2J!  %   %d A%&*>*>*> ! #% ') D%*4[ "B ~J%,,T2 ''-'''"000%++-"&K  f)# # #!1" $sZAF ?F 7F :F F  F F#F 3F ;F F 9F >F ? F  F c V^8dQhRRRR/#)r3 specifier_setrr4rr$)r5s"r1r6r#s* * * * r0c  *V'gVP4pMVP'g4VP\\ VP 444R7pMVP4pVFpVP R8Xd7VPR\VPP404R7pM2VP\\ VP444R7pVPV4pK .pVPf^VFWpVP R8wgKVP'gK*\\ VP444p\WV4pKY VP\ V4VPR7#)a9Build the range accepted by ``specifier_set``. Friend constructor for :meth:`~packaging.specifiers.SpecifierSet.to_range`. The intersection of every specifier in the set: an empty set yields the full range, an unsatisfiable set yields the empty range, and ``===`` specifiers contribute literal-string admission. )r^===)r^r,)r)rVr$)rc_has_arbitraryr7rbru _get_rangesoperatorr5rHrO _to_rangesru _prereleasesr[rVrY)r&rrZspecoperandr spec_boundss&& r1_from_specifier_set VersionRange._from_specifier_setsPXXZF---ZZ'm.G.G.I(JK FXXZF%==E)!jj!DLL4F4F4H3I)J)G"jj/doo6G0HI)G ,,W5&"$  % % -%==E)d.>.>.>"259J3K"LK*6?F & ""V}$11#  r0cV^8dQhRR/#)r3r4zSpecifierSet | Noner$)r5s"r1r6r#sOO"5Or0c d^RIHpHpVPpVP'dR#VP 'dVP \8wdR#VP'd V!RVR7#VP 'g3\VP4^8wdR#VPwpRV 2.pEMVP'dR#VP \8XdVP 'dRMR.pMVP .pVRJd7\VP 4pWpP 8wdVPV4.pVF|p\V4p V fKR Fbp \V^,^,VR ,^,V 4p V fK2R PW,4p W9gKQVPV 4Kd K~ VRJ;'dVP VP 8Hp RpR pVFp V .pV 'dTPV 'dV R 2MR4VFpV!VVR7p\T4\\#T443pTe TT8dK:TP%4pTT8H;'gTRJ;'dTP'T4pT'gK~TTrK K V# TdKi;i)aReturn a :class:`~packaging.specifiers.SpecifierSet` matching the same versions as self, or ``None`` if no single set expresses it. PEP 440 has no syntax for the strict singleton ``{V}`` (an exclusive plain-version bound), a disjoint union of two or more intervals, or a partial pre-release opt-in region, so ranges built by set algebra often return ``None``. A gap that takes more than ``_MAX_EXCLUSION_RUN`` contiguous ``!=`` exclusions to spell returns ``None`` too, rather than a pathologically long chain; reaching that cap takes either set algebra or a specifier set that already spells the gap out with over a hundred contiguous ``!=N.*`` exclusions. An empty range maps to ``SpecifierSet("<0")``, unless it still carries the arbitrary-string flag (which no set reproduces), and a full range that admits arbitrary strings maps to ``SpecifierSet("")``. A range built from a :class:`~packaging.specifiers.SpecifierSet` re-encodes, short of that exclusion cap. The result is the simplest candidate whose own :meth:`~packaging.specifiers.SpecifierSet.to_range` reproduces self exactly (bounds, ``===`` literals, and the opt-in region are all part of equality), so it filters the same versions. Two cases relax that exactness without changing what is filtered: an empty range recovers as the canonical empty range (same versions, none, but not self's bounds), and under a ``prereleases=False`` policy the result need only match self's releases, so ``(-inf, 3.14)`` recovers as the tighter ``<3.14`` rather than ``!=3.14,<=3.14``. Each call encodes a handful of candidate spellings and keeps the simplest one that verifies, where verifying means parsing the candidate and round-tripping it through :meth:`~packaging.specifiers.SpecifierSet.to_range`. The work grows with the number of intervals and exclusions in the range, and the result is not cached, so convert once and reuse the returned set rather than converting per candidate version in a hot loop. >>> str(SpecifierSet(">=1.0,<2.0").to_range().to_specifier_set()) '<2.0,>=1.0' >>> str(SpecifierSet("==1.0").to_range().to_specifier_set()) '==1.0' >>> VersionRange.singleton("1.5").to_specifier_set() is None True )InvalidSpecifierrNz<0)r[rz>=0.dev0F,z ,>=0.dev0)FTrC)rr) specifiersrrrrrrrrrErrrFrrrrr~to_ranger)r=rrrVr}baseslayouts tightenedlayoutr routerrp add_floorbestbest_key candidatesspec_str recoveredrrmmatchess& r1to_specifier_setVersionRange.to_specifier_setsnV ?11 <<<  T\\Z%? === *= =|||4;;1$JW7)_%E [[[ \\Z '000RjAE ||nGU"3DLLA  ,NN9- E!)&1 %!.I,VAYq\6":a=)TE} 88E$67D( T* "/ ""$&KK4+;+;t||+K %)DJ!!TF)"4*M&  ,X: NI 9~s3y>':;#x&..0 #t+%'JJD,?,? ,J7%.(1' > %(s J$$J/.J/cV^8dQhRR/#r:r$)r5s"r1r6r#QsQQ$Qr0c 2VP4'dR#VPRJpVPF/pV'd$\V4pVeVP'dK.R# VP 'gR#T;'d\ VP 4#)a``True`` if no version or string satisfies this range. Agrees with :meth:`~packaging.specifiers.SpecifierSet.is_unsatisfiable`, including the pre-release policy: a range whose only members are pre-releases is empty when that policy excludes them. >>> SpecifierSet(">=2,<1").to_range().is_empty True >>> SpecifierSet(">=1,<2").to_range().is_empty False >>> SpecifierSet("==1.0a1", prereleases=False).to_range().is_empty True FT)rBrrrrrr)r=excludes_prereleasesr}rs& r1rVersionRange.is_emptyPs"  ! ! # ##;;uD{{G#'0%&*>*>*> #|||#PP(B4<<(PPr0c(V^8dQhRRRRRRRR/#)r3rrfr[r installedr4r|r$)r5s"r1r6r#qs8D7D7D7!D7 D7  D7r0c ,\V\\34'g"\R\ V4P 24h\V\4'dTMRpV'dVf \ V4pV'dVeVP'dRpVf VPMTpVP'gVP'dg\V4P4pW`P9dR#W`P9d,VRJd$\ V4pVeVP'dR#R#\V\4'g&Vf \ V4pVfVP4#TpVRJdVP'dR#\VPV4#)aReturn whether item is contained in this range. :param item: a version string or :class:`~packaging.version.Version`. :param prereleases: whether to match pre-releases. ``None`` (default) uses the range's own policy. :param installed: when ``True``, accept a pre-release item even if the range would not otherwise allow it. Unlike :meth:`filter`, this does not consult the autodetected pre-release opt-in region; it reads only the configured policy. This mirrors :meth:`~packaging.specifiers.SpecifierSet.contains` versus :meth:`~packaging.specifiers.SpecifierSet.filter`. Unparsable strings do not match, except where the full ``SpecifierSet`` would also match: the full range admits any string, and a ``===`` range admits items equal to the literal case-insensitively. >>> r = SpecifierSet(">=1.0,<2.0").to_range() >>> r.contains("1.5") True >>> r.contains("2.0") False :raises TypeError: if item is not a str or Version. z5VersionRange.contains() expected str or Version, got NTF)rar~rr%rLr%rrrrrrOrBrr)r=rr[rr effective_preitem_strliteral_parseds&&&& r1containsVersionRange.containsqsQ@$g//Dz**+-  *4D')B)B #D)F +0D0D0DK-8,?D ( ([  ;;;$,,,4y(H<<';;& E)%3H%=N%1n6R6R6R$$((~'-~--//D E !d&8&8&8"4<<66r0c V^8dQhRRRR/#)r3rrfr4r|r$)r5s"r1r6r#s###4#r0c $VPV4#)zReturn whether item is contained in this range. Forwards to :meth:`contains` with default arguments. >>> "1.5" in SpecifierSet(">=1.0,<2.0").to_range() True )r)r=rs&&r1 __contains__VersionRange.__contains__s}}T""r0c V^8dQhRRRR/#)r3rIr!r4r|r$)r5s"r1r6r#s% % F% t% r0c \V\4'g\#VPVP8H;'dVPVP8H;'d}VP VP 8H;'d\VP VP 8H;'d;VPVP8H;'dVPVP8H#)aStructural equality. Compares the bounds, the ``===`` admit/reject literals, the arbitrary-string flag, the configured pre-release policy, and the opt-in region, not just the version set. Keying on the region makes equality a congruence (equal ranges stay equal under further operations), so equal implies same :meth:`contains` and :meth:`filter`, but not the converse: an empty range keeps the flag it was built with, so two empty ranges need not be equal. Different specifiers for the same range fold to one canonical form: >>> SpecifierSet(">1.0a1").to_range() == SpecifierSet(">=1.0a2.dev0").to_range() True The opt-in region is part of equality, so ``<=1.0`` (no pre-releases) and ``<1.0.post0.dev0`` (autodetects a ``.dev`` opt-in) cover the same versions yet compare unequal: >>> le, lt = SpecifierSet("<=1.0"), SpecifierSet("<1.0.post0.dev0") >>> le.to_range() == lt.to_range() False >>> r = SpecifierSet(">=1.0,<2.0").to_range() >>> r == SpecifierSet(">=1.0,<2.0").to_range() True ) rarrrrrrrrrNs&&r1__eq__VersionRange.__eq__s8%..! ! LLEMM ) 6 6 u||+ 6 6  - 6 6%%)?)?? 6 6,,0M0MM  6 6   E$5$55  r0cV^8dQhRR/#)r3r4rr$)r5s"r1r6r#s   #  r0c \VPVPVPVPVP VP 34#r8)hashrrrrrrr<s&r1__hash__VersionRange.__hash__sD   %%,,     r0cV^8dQhRR/#)r3r4r~r$)r5s"r1r6r#s==#=r0c .pVP'd%VP\VP44VP'dBVPRRP \ VP44,R,4V'dRP V4MRpVP 'd+V RRP \ VP 44 R2pRpVP'd VR, pVPeVR VP 2, pVP'd!VR \VP4: 2, pR VPP R V: V R 2#)aHuman-readable representation for debugging. >>> SpecifierSet(">=1.0,<2.0").to_range() >>> SpecifierSet("").to_range() >>> SpecifierSet(">=2.0,<1.0").to_range() {r}rz(empty)z \ {rz arbitraryz pre=z pre-region=r r) rrFrrrsortedrrrr __class__r%)r=rbodyrs& r1__repr__VersionRange.__repr__s* <<< LL*4<<8 9 ;;; LLtyy )<==C D$)uzz% y <<<V6$))F4<<,@"A!B"ED  L D  ' ' 3 eD889: :D     l#4T5E5E#F"IJ JD4>>**+1THTF!<rBrFrOrSrYr_rcrhruryr~rrprrrrrrrrrtypingoverloadrrrrpropertyrrr rrrr/r$r0r1rrs(TI"!  &%)( !* !* % 6,.6/366p7D  I$  BBB (, IM  0 CG  <' R- ^  D? B& P 9( ! !& !/F%"1*S __++ __( TU$n* * XObQQ@D7L#% N  ==r0)Er) __future__rr*r#rrrr_rangesrrr r r r r rrrrrrrrrrHrcollections.abcrrrrrrrr9rr~UnparsedVersionr rEnumr#r:rVr[rbrqryrrrrrrrrrrrrrrrr rrrr$r0r1r+s+ # $FF!(   CL %1ITYY4n%P2&R6 /&;;$ *F./b$>"B2jFDA%N:B% 2j@F(:L=L=r0