#jnDXdZddlmZddlZddlZddlmZmZmZmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZddlmZerddlmZmZmZm Z dd l m!Z!dd l"m#Z#d gZ$ed Z%eee&fZ'ed e'Z(dZ)GddejTZ+d+dZ, d,dZ-d-dZ.d.dZ/d/dZ0d.dZ1 d0dZ2d1dZ3d2dZ4d3dZ5d4dZ6d5dZ7d6dZ8 d7dZ9d8d Z:d9d!Z;d:d"Z d=d%Z?e)f d>d&Z@d?d'ZAd@d(ZBd.d)ZCGd*d ZDy)Aa 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)boundcveZdZdZej Zej Zej Zy)_SetOpzNThe binary set operation ``_combine_literals`` resolves over ``===`` literals.N) __name__ __module__ __qualname____doc__enumauto INTERSECTIONUNION DIFFERENCET/var/www/oz-panel.ru/ozpay-pub/venv/lib/python3.12/site-packages/packaging/ranges.pyr&r&Ks,X499;L DIIKEJr1r&ctSN)__all__r0r1r2__dir__r6Ss Nr1c|s t|S|s t|Sg}dx}}|t|kro|t|kra||d||dkr|j|||dz }n|j|||dz }|t|kr|t|kra|j||d|j||d|dg}|ddD]\}}|d\}} | j%|j| j|jkDrd} n| j|jk(r| j xs |j } nNt | j| j } t|j|j } t| | } | r|t| |f|d<|j||f|S)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. rrNT) listlenappendextendversion inclusiverrrmax) leftright merged_input left_index right_indexmergedlowerupper prev_lower prev_upperoverlaps gap_lower gap_uppers r2 _union_rangesrM\s E{ Dz#%L  J s4y [3u:%=  A % "4Q"7 7   Z 0 1 !OJ   k 2 3 1 K s4y [3u:%=Z[)*kl+,*1o.F$QR(* u!' J    &}}$!!EMM1H   5== 0!++>uH #:#5#5:;O;O7OPI"5==eoo2EFI%i;H $c*e&<=F2J MM5%. )-*0 Mr1c|sttSg}d}|D]\}}|E|jt|j|j }|j t |fnUt|j|j }t|j|j }|j ||f|}|J|j8t|j|j }|j |tf|S)aComplement 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) r9r r=rr>r;r rr )rangesresultrIrFrGrLrKs r2_complement_rangesrQs JF$(J u   }}(&u}}%//6IJ  w 23":#5#5:;O;O7OPI"5==eoo2EFI MM9i0 1 !&  !! !%z11z7K7K3KL  y'*+ Mr1c|s|S|d\}}tt|r|ddS|jr=0.dev0`` becomes the one canonical full range. An exclusive upper at or below it leaves the interval empty, so it is dropped. rrN)rr r> isinstancer=rr )boundsrFrGs r2_canonical_floorrUsp  !9LE5gu%abz  u}}g . MM[ (% .6!":.. Mr1c|jyd}|j`|jdk(rQ|jE|j\}}|dk\rt|j ||dz fdt j }n|jdk\r8t|j |jdz t j}nw|jdk(rh|j\|jdk(r|j ddn|j |jdz d}t|t j}|t||k(r|Sy)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``. Nrr)predevrXpostrX) rXrWr[r __replace__r AFTER_POSTS AFTER_LOCALSr)r= candidatekindnumberbases r2_predecessor_boundaryrcs;{{(,I{{7;;!#3 8L{{ f Q;'##vz(:#E((I  #   GKK!O  4l6O6O   gll6||q    Tt  4$$',,*:$E $D,*C*CD !4Y!?7!J r1cg}|D]\}}||}}t|jtr0|jr$t |j}| t |d}t|jtr0|js$t |j}| t |d}|j||ft|S)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. Fr>T) rSr=rr>rcrrr;tuple)rTrPrFrG new_lower new_upperboundarys r2 _canonicalizerjs F . u$e9 emmW -%//,U]];H#&x5A emmW -eoo,U]];H#&x4@  y),- . =r1cNt|}| |xr |tk(St||S)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. )rr r)rTadmit_arbitraryliteralparseds r2_struct_admitsros0G $F ~76Z#77 vv ..r1ct|tr&|jd|jjdSt |S)z?Printout for a bound's inner value, kind-tagged for boundaries.[])rSrr=r`namestr)values r2_bound_version_strrv+s6%)--%**//!2!44 u:r1cn|jy|jrdnd}|t|jS)Nz(-infrq(r=r>rvr#brackets r2 _format_lowerr|2s6 }}__c#GY)%--89 ::r1cn|jy|jrdnd}t|j|S)Nz+inf)rr)ryrzs r2 _format_upperr9s5 }}__c#G / 0 ::r1c2djd|DS)zARender a sorted interval list as ``lower, upper | lower, upper``. | c3TK|] \}}t|dt|"yw), N)r|r).0rFrGs r2 z$_format_intervals..Bs0>JeU=  =#7"89s&()join) intervalss r2_format_intervalsr@s ::NW r1c|jdk(xr.|jduxr|jduxr|jduS)zFTrue when version is exactly ``X[.Y]*.dev0`` (the shape ``rZr8epochrelease!=.*>=) rXrWrr[r\rrr from_partsrany)r=familylast below_releasebelows r2 _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``. Nrr)r)rrrXFrr)r=rSrr`r r^rXrr>rrWr[rrrrrr)rFrGr= excluded_devs next_familycaprs r2_epoch_floor_lowerrsmmG'?+ <<<44 4// ;;  a GW %%// ;;!  }}{{',,":gmm>W < ()$$7==$ANK [% (C s{   gmmT BF =%3, ..r1c|tkrgSt|}||S|j,|jdk(r|j dd}d|d|gSy)aBPrerelease-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. NrrZrr)r rrWr[r\)rcleanrbs r2_dev_family_anchorrsj  E   zzfkkQ.!!t!6TF r$[)) r1cv|j}|gSt|tr|jtj k(rd|jgS|j}|t krd|gS|s|js|jd}t|}|r|jdztkDryt|jdzDcgc]}d|j|}}||zSt|}| t|nd} | | Sd|d|gS|jsy|st|} | | Sd|gScc}w)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. NrrrrYrr)r=rSrr`r r]r rXr\r_MAX_EXCLUSION_RUNrangerrr>) rF keep_dev0 lower_versioninnerranchordrun successorrs r2 _encode_lowerrs|MMM -1   !9!9 9 --./0 0%% K L> !yy$ **q*1+F3%yy1}'99#BG TU BV=>"V//A/678C"C<'0 > 3<3H Y/d$ L UG 5'l++ ?? ]+  L !!3sD6c|j}|gSt|tr|jtj k(r[|j}|sG|j ;|j/|j#d|j|jdzgSd|gSt|}|d|gSy|jsO|jdk(r6|j *|j|sd|jdgSd|gSd|d|gSy) a4Encode an upper bound as specifier fragments, or ``None``. ``[]`` for ``+inf``. In the prerelease-free spelling mode (``keep_dev0`` false) the ``r)rGr upper_versionrrs r2 _encode_upperrs<MMM -1   !:!: :!))EII%JJ*II% E--5::>-BCDEEL> !( 6   {O$ $ ??    "!!)##+M55$5?@ABB '( (]O$=/&:;; r1ct|jtst|jtry|j |jy|jr |jryt |jrt |jsy|jj |jj k7ryt |jj}t |jj}tt|t|}|dkDsJ|d|t|z zz }|d|t|z zz }|dd|ddk7ry|d|ddzk7ry|jj|dS)z;If ``[lower, upper)`` is the ``==V.*`` shape, return ``V``.Nrrr8r)rrX) rSr=rr>rrrrr?r:r\)rFrG lower_release upper_release padded_lengths r2_detect_equal_wildcardr8sR%--1Z 6 }} 5 ??eoo U]] +0@0O }}emm111 !6!67M !6!67MM*C ,>?M 1  T]S-??@@MT]S-??@@MSb]3B// RM"-11 == $ $] $ EEr1c |j|jt|jtsqt|jtsW|jrK|jr?|j|jk(r&|jjd|jgSt|jt r|jr|jrtt|jtrZ|jj tjk(r3|jj|jk(rd|jgSt||}|d|dgS|s t||nd}|^|\ }}|tkDryd dg}|j fdt|D|s t||}|y|j||St||} | yt||}|y| |zS)aEncode 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==rc3HK|]}dj|ywrrYNr\)rrrs r2rz#_encode_interval..s'T!r&,,,345T")r=rSrr>rrr`r r^rrrr<rrr) rFrGrwildcardfloorr upper_at_capparts upper_parts lower_partsrs @r2_encode_intervalrZs  ! MM %5==/:5==/: OO OO MMU]] * MM   +U]]O$%% 5=='* OO OO u}}o 6 MM  ,";"; ; MM ! !U]] 2U]]O$%%%eU3HXJb!""5> ue ,4E .3+ | - -fXR! Tu]?STT'y9K" LL % y1Ky1K  $$r1cvt|jtrt|j}|&y|j |jry|j}t|jts7|j*|js|j|k(r|j |gSy|jj tjk7ry|jj}||k(r|gStt|tjj|j|jjk\rt|jjk(rU|jjz dztkDryfdtj|jdzD}|g|Sy)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)``. NrYc3BK|]}j|yw)rYNr)rrseconds r2rz$_detect_not_equal..sRQv!!a!(Rsr) rSr=rrr>rr`r r^rXr\rr) left_upper right_lowerfirstrrrs @r2_detect_not_equalrs*$$o6$J$6$67 =    #z';';"" k))? ;    +))##u, '7N<#<#<<    & &D }w! 8Q8Q!R SF JJ " HH HH "     , 6 88fjj 1 $'9 9R% DHHqL2QR}} r1c  d}|t|krF|t|kr8||||k(r-|dz }|t|kr|t|kr ||||k(r-t||dzkDry|d|}t||kDr||nd}||}||z }||kDryt||D cgc]} tj|g||  } } t||dzk(r| St g|||||t |dz } | y| | zScc} w)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. rrNr)r:rrr_decompose_dev0_gapr?) lower_trim upper_trimrbudgetdiffcommon lower_val upper_valspansegment fragmentstails r2rrsX D s: 3z? " t  4 0 0   s: 3z? " t  4 0 0 :!  F$' Od$: 4 I4 I y D f}Y 2  0B&0B'0BCI  :$(" &)j%#dA,1F D | t #s!#Dc t||}||Dcgc]}d| c}S|j}t|tr|js t |sy|j}t|tr|jr | d}t }nt|tr|jtjk(rf|jsZ|j}|j|jdzt kDry|jd |jdz}t |z }nyt sy|j jk7s| k\rytt|j t j |j|} | y| D cgc]} d| d } } | j# fdt%|D| Scc}wcc} w)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``. NrrrrYrc3HK|]}dj|ywrr)rr upper_dev0s r2rz_encode_gap..Rs'Vq:11a189:Vr)rr=rSrr>rrrr`r r^rXr\rrrrr<r) rrpointspointleft_vright_v run_lengthrrGprefixesprefix exclusionsrs @r2 _encode_gaprsz; 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/9J9VE*DUVV i2d:s G Gcg}tdt|D]2}t||dz d||d}|y|j|4|S)aEncode 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. rrN)rr:rr<)rTrindexgaps r2 _encode_gapsrVsdJq#f+&&+A.u a0@A ;#  r1c|d\}}|j}t|trM|jsA|js5|j )t |jdd}g|dd||fS|S)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 `` is_prereleaserrr\)rTrFrGr=s r2_tighten_no_prereleasesrjsw ":LE5mmG7G$%% MM !7..1.5G--uen-- Mr1ceZdZUdZdZded<ded<ded<ded <ded <d ed <d9d Zeeedfddd d:dZ d;dZ d;dZ d;dZ ddZeddd?dZeddd d@dZedd dAdZdBdZdBd ZdCd!ZdBd"Z dDd#ZdEd$ZdFd%ZdFd&ZdCd'ZdFd(ZdGd)ZdGd*ZdGd+ZdGd,Z e!jD dH dId-Z#e!jD dH dJd.Z# dK dLd/Z# dMd0Z$edNd1Z%dOd2Z&e'd;d3Z( dK dPd4Z)dQd5Z*dRd6Z+dSd7Z,dTd8Z-y)Ur aA 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_rejecttuple[Interval, ...]rboolrfrozenset[str]rrr bool | Nonerctd)Nzcannot create 'VersionRange' instances directly; use SpecifierSet.to_range(), VersionRange.full(), VersionRange.empty(), or VersionRange.singleton() instead) TypeError)clsargskwargss r2__new__zVersionRange.__new__s H  r1Fr0N) pre_regionprereleases_configuredc^t|r|r||z }|rtfd|D}|rtfd|D}tj|}|_||_||_|_||_||s d|_ |Sttt||_ |S)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. c3<K|]}t|s|ywr4rorrmrlrTs r2rz&VersionRange._build..s%%fowGc3<K|]}t|r|ywr4rrs r2rz&VersionRange._build.. s%!&/7Crr0) rj frozensetobjectrrrrrrrrfr)rrTadmitrejectrlrrinstances ` ` r2_buildzVersionRange._builds(v& VFNE $E %F >>#&!!$3!+A( " -Z#%H  $) z!:FC$H r1cZt|jxst|jSr4)rrrselfs r2 _has_literalszVersionRange._has_literals%sDKK 6D$66r1cD|jxr|jtk(S)asTrue 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. )rrr r s r2_arbitrary_activezVersionRange._arbitrary_active(s$$C)CCr1cb|j xr|j xr|jduS)zTrue when membership is decided by ``_bounds`` alone, enabling the bounds-only fast paths in :meth:`is_subset` and :meth:`is_disjoint`. F)rrrr s r2 _is_plainzVersionRange._is_plain2s< ""$ $ :))) :,,E9 r1ct|ts!tdt|j|j |j k7r%t d|j d|j y)z{{ LL++<< 11!#-   r1 prereleasesc(|jd|S)zReturn the empty range. No version satisfies it. >>> VersionRange.empty().is_empty True >>> "1.0" in VersionRange.empty() False r0r)r )rr s r2emptyzVersionRange.emptyfszz"[zAAr1T)rlr c2|jt||S)ahReturn 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 )rlr)r r )rrlr s r2fullzVersionRange.fullqs#&zz +#.  r1ct|ts t|}t|d}t|d}|j t ||ff|S)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")rSrrrr rU)rr=r rFrGs r2 singletonzVersionRange.singletonsZ$'7+g&G7D)7D)zz uen. /#.  r1c|j||j}tt|j|j}|j |}|j xr|j xr t|}|js%|js|j||||S|j||tj|||S)auRange 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 rlrroprlrr) rrrfrrrrrrr _combine_literalsr&r-r rr new_bounds new_region combined_arbs r2 intersectionzVersionRange.intersections !!%(11 +DLL%--HI ((/  ! ! Qe&<&< QjAQ !!#E,?,?,A;; ,%'1  %%  ""(!#- &  r1c.|j||j}tt|j|j}|j |}|rI|j xrt|jxs#|j xrt|j}n|j xs |j }|js%|js|j||||S|j||tj|||S)aRange 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 r)r*) rrrfrMrrrrrr r,r&r.r-s r2unionzVersionRange.unions !!%(11 =u}}EF ((/  11Hd4<<6H&&>4 +>   00JE4J4JL!!#E,?,?,A;; ,%'1  %%  ||(!#- &  r1c|jtt|j|j|j |j d|jS)aRange 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 r0r)r rfrQrrrrrr s r2 complementzVersionRange.complementsO2{{ $T\\2 3,,;; 11#'#?#?   r1c|j||js|js|Stt |jt |j}d}|j |j}|jxr||jk(}|js/|js|j||||j S|j||tj|||j S)a8Range 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 r0r)r*)rrrrfrrQrrrrr r,r&r/)r rr.r/r0s r2 differencezVersionRange.difference#s. !!%(}}U\\K T\\+=emm+L M ,.  ' ' /))J ,,Kt||1K !!#E,?,?,A;; ,%'+'C'C  %%    (!#'#?#? &  r1ct}t}|j|jz|jz|jzD]} |j| } |j| } |tj ur| xr| } n |tj ur| xs| } n| xr| } | r|j| r|j| |j|t|t||||S)zGResolve admit/reject for ``self`` ``op`` ``other`` over their literals.r) setrr_matches_literalr&r-r.addr r) r rr.r+rlrradmitsrejectsrmself_inother_inwants r2r,zVersionRange._combine_literalsds5E{{T\\1ELL@5==P %G++G4G--g6HV(((+8v||#*(/x< 7# G$ % {{ F#W%+!#9   r1c||jvry||jvryt|}||jSt |j |S)z=Whether literal (case-folded) matches this range's predicate.FT)rrrrrr)r rmrns r2r:zVersionRange._matches_literalsO dll " dkk !( >))+ +"4<<88r1cPt|tstS|j|S)z(Operator alias for :meth:`intersection`.)rSr NotImplementedr1rs r2__and__zVersionRange.__and__s#%.! !  ''r1cPt|tstS|j|S)z!Operator alias for :meth:`union`.)rSr rCr3rs r2__or__zVersionRange.__or__s!%.! !zz%  r1c"|jS)z&Operator alias for :meth:`complement`.)r5r s r2 __invert__zVersionRange.__invert__s  r1cPt|tstS|j|S)z&Operator alias for :meth:`difference`.)rSr rCr7rs r2__sub__zVersionRange.__sub__s!%.! !u%%r1c0|j||jr|jsy|jr:|jr*t|jt |j S|j |jS)aReturn 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)rrrrrrQr7is_emptyrs r2 is_subsetzVersionRange.is_subsetsx( !!%(  ! ! #E,C,C,E >>  1' 6H6WXX Xu%...r1cF|j||j|S)aReturn 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 )rrMrs r2 is_supersetzVersionRange.is_supersets! !!%(t$$r1c|j||jr1|jr!t|j|j S|j |j S)aReturn 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 )rrrrr1rLrs r2 is_disjointzVersionRange.is_disjointsV !!%( >>  1' emmDD D  '000r1cr|j|jxr|j|jS)aWhether 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. )r7rLrs r2_same_releaseszVersionRange._same_releasess/u%..R53C3CD3I3R3RRr1cyr4r0r iterabler keys r2filterzVersionRange.filters (+r1cyr4r0rUs r2rXzVersionRange.filter s r1c<d}||j}|j}|j}|jsP|jsD|sB|r'||j k(rt |j ||dSt |j ||||S|j|||||S)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'] r0T)rrrrrrr_filter_with_admission)r rVr rWregionarbitrary_actives r2rXzVersionRange.filters,(*  66K%%F113{{4<<8H &DLL0' hTJJ#DLL(CfU U** c;(8&  r1c#VKjjdfd }|dur|D]}||\}} } |s|y|dur*|D]$}||\}} } |s| | jr!|&yg} g} d} |D]}||\}} }|s| *| r|n"| j|| j|>| js#| s| Ed{| j d} |m|s|rt || r|| r| j|| s | Ed{yy7T7w)zFilter for ranges with admit/reject literals or live arbitrary admission (including the universal ``SpecifierSet("")`` range).c|n|}t|j}r|vryr|vrdt|dfSt|}|ddfStj|syd|dfS)N)FNFTF)rtrFrrr) itemraw raw_lowerrn admit_setr]rW reject_setr s r2rz2VersionRange._filter_with_admission..admitHs),#d)CC(Ii:5)Y)3^C0$66#C(F~'u44&t||V<)& &r1TNF)r`rreturnz!tuple[bool, Version | None, bool])rrrr;clearr)r rVrWr r]r\rr`ok_rn all_nonfinalarbitrary_strings found_final by_literalrcrds` ` ` @@r2r[z#VersionRange._filter_with_admission;szKK \\  ' '" $    ;AqJ   %    %d FA%&*>*>   #% ')  *D%*4[ "B ~J%,,T2 ''-''"000%++-"&K  f)# # #!1" $s0:D)BD)D%2D)D)D'D)'D)c |s|j}n|js3|jtt |j }n|j}|D]}|j dk(r6|jdt|jjh}n2|jtt |j}|j|}g}|jR|D]M}|j dk7s|js tt |j}t||}O|jt ||jS)aaBuild 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. )rT===r0)rTr)rr)r%_has_arbitraryr rUrf _get_rangesoperatorrr=rF _to_rangesr1 _prereleasesr rMr)r specifier_setrPspecoperandr\ spec_boundss r2_from_specifier_setz VersionRange._from_specifier_setsXXXZF--ZZ'm.G.G.I(JK FXXZF% 6==E)!jj!DLL4F4F4H3I)J)G"jj/doo6G0HI)G ,,W5 6"$  % % -% @==E)d.>.>"259J3K"LK*6;?F  @ ""V}$11#  r1c`ddlm}m}|j}|jry|j r|j tk7ry|jr |d|S|j s.t|jdk7ry|j\}d|g}n|jry|j tk(r|j rdndg}n|j g}|d ur5t|j }||j k7r|j|g}|D]]}t|} | d D]H} t|d d |d d| } | d j| | z} | |vs8|j| J_|duxr|j |j k(} d}d}|D]} | g}| r|j| r| dnd|D]i} |||}t|tt#|f}|||k\r5|j%}||k(xs|d uxr|j'|}|sf||}}k|S#|$rYwwxYw)a Return 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 r)InvalidSpecifierrNz<0rrnz>=0.dev0F)FTrr8,)rrz ,>=0.dev0) specifiersrzrrrrrr rLr:rrr;rrrrrtto_rangerS)r rzrrrmbaseslayouts tightenedlayoutrrouterrb add_floorbestbest_key candidatesspec_str recoveredrWr_matchess r2to_specifier_setzVersionRange.to_specifier_setsoV ?11 <<  T\\Z%? == *= =||4;;1$JW7)_%E [[ \\Z '00RjAE ||nGU"3DLLA  ,NN9- E! +)&1 %!.+I,VAYq\6":a=)TE} 88EJ$67D5( T* + +"$&K4+;+;t||+K %) 4DJ!!TF)"4*M& 4  ,X: NI 9~s3y>':;#x&..0 #t+%'JD,?,? ,J%.(D1 4  4> %(s9 H%%H-,H-c|jry|jdu}|jD]}|rt|}| |jry|j sy|xrt |j S)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)rrrrrrr)r excludes_prereleasesrmrns r2rLzVersionRange.is_emptyPsy"  ! ! ##;;uD{{ G#'0%&*>*>  ||#P(B4<<(PPr1ct|ttfs!tdt |j t|tr|nd}|r | t |}|r||jrd}| |jn|}|js |jrUt|j}||jvry||jvr|durt |}| |jryyt|ts!| t |}||jS|}|dur |jryt|j|S)aIReturn 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)rSrtrrrr'rrrrrrFrrr)r r`r  installedrn effective_preitem_strliteral_parseds r2containszVersionRange.containsqs?@$g/Dz**+-  *4D')B #D)F +0D0DK-8,?D ( ([  ;;$,,4y(H4<<'4;;& E)%3H%=N%1n6R6R$$(~'-~--//D E !d&8&8"4<<66r1c$|j|S)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 r`s r2 __contains__zVersionRange.__contains__s}}T""r1cnt|tstS|j|jk(xr|j|jk(xrj|j |j k(xrO|j |j k(xr4|j|jk(xr|j|jk(S)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 ) rSr rCrrrrrrrs r2__eq__zVersionRange.__eq__s8%.! ! LLEMM ) 6 u||+ 6  - 6%%)?)?? 6,,0M0MM  6   E$5$55  r1ct|j|j|j|j|j |j fSr4)hashrrrrrrr s r2__hash__zVersionRange.__hash__sD   %%,,     r1ctg}|jr$|jt|j|jr9|jddj t |jzdz|rdj |nd}|j r*|ddj t |j d}d}|jr|dz }|j|d |jz }|jr|d t|jz }d |jjd ||d S)a<Human-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 \ {r{z arbitraryz pre=z pre-region=r r) rr;rrrsortedrrrr __class__r')r rbodyrs r2__repr__zVersionRange.__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!<rs # $FF!(   CL %1ITYY4 4 44n%P2&R6 /  /37 /BE /  /&;;$ *F./ ./(./%./b$>"B2jFDA% A%(A%59A%A%N::)3::B% 222 2  2  2j@F(:L=L=r1