o gj>@sUdZddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZddlmZddlmZeruddlZdd lmZmZmZejd krcdd lm Z ndd l!m Z dd l"m#Z#dd l m$Z$gdZ%dddZ(e dZ)e ee*fZ+e de+dZ,ej-ej.ej/ej0dZ1d e2d!<d?d'd(Z3Gd)d*d*e4Z5Gd+d,d,ej6d-Z7Gd.d#d#e7Z8d@d5d6Z9Gd7d8d8e7Z:dAd:d;Z;dS)Bz .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN) TYPE_CHECKINGAnyCallableFinalTypeVarUnion) FULL_RANGEbounds_for_speccoerce_versionfilter_by_rangesintersect_specifier_boundsmatches_bounds_onlyranges_are_prerelease_onlyresolve_prereleases trim_release)canonicalize_version)Version)IterableIteratorSequence) ) TypeGuard)ranges)Interval) BaseSpecifierInvalidSpecifier Specifier SpecifierSetreturn list[str]cCstSN)__all__r%r%T/var/www/html/laksyashrimp/venv/lib/python3.10/site-packages/packaging/specifiers.py__dir__<sr'specobjectTypeGuard[tuple[str, str]]cCs2t|tot|dkot|dtot|dtS)Nrr ) isinstancetuplelenstr)r(r%r%r&_validate_spec@s    r0preTypeGuard[bool | None]cCs|dupt|tSr#)r,bool)r1r%r%r& _validate_preIsr4TUnparsedVersionVar)bound)>=<===!=z-dict[str, Callable[[Version, Version], bool]]_DIRECT_COMPARE_OPS specifierrparsedr bool | NonecCs|j\}}|ds|jdurdSt|}|dur"||||S|dvrI||}|j|jks;t|jt|jkrG|dkrC||kS||kSdSdS)a!Match ``parsed`` against ``specifier`` without building a range. Handles ``>=``, ``<=``, ``==``, ``!=``, ``<``, ``>`` when the spec is not a wildcard and ``parsed`` has no local. Returns ``None`` when the range path must be used. Pre-release policy is left to the caller. .*N)<>rA) _specendswithlocalr<get_require_spec_versionepochrrelease)r=r>op_strver_strdirect_comparespec_vr%r%r& _fast_match]s   rNc@seZdZdZdS)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)__name__ __module__ __qualname____doc__r%r%r%r&rzsrc@seZdZdZdZdZed,ddZej d,dd Z ej d-d d Z ej d.ddZ eej d/ddZ e jd0ddZ ej d1d2ddZej  d3d4d"d#Zej  d3d5d'd#Zej  d6d7d+d#ZdS)8rzO Abstract base class for :class:`Specifier` and :class:`SpecifierSet`. r%)_strr!r/cCst|S)z Internal property for match_argsr/selfr%r%r&rSszBaseSpecifier._strcCdS)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr%rUr%r%r&__str__zBaseSpecifier.__str__intcCrW)zF Returns a hash value for this Specifier-like object. Nr%rUr%r%r&__hash__rYzBaseSpecifier.__hash__otherr)r3cCrW)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nr%rVr\r%r%r&__eq__rYzBaseSpecifier.__eq__r?cCrW)zWhether 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. Nr%rUr%r%r& prereleasesrYzBaseSpecifier.prereleasesvalueNonecCrW)zQSetter for :attr:`prereleases`. :param value: The value to set. Nr%rVr`r%r%r&r_rYNitemr_cCrW)zR Determines if the given item is contained within this specifier. Nr%)rVrcr_r%r%r&containsrYzBaseSpecifier.contains.iterableIterable[UnparsedVersionVar]keyIterator[UnparsedVersionVar]cCdSr#r%rVrer_rgr%r%r&filterzBaseSpecifier.filter Iterable[T]Callable[[T], UnparsedVersion] Iterator[T]cCrir#r%rjr%r%r&rkrl Iterable[Any]'Callable[[Any], UnparsedVersion] | None Iterator[Any]cCrW)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr%rjr%r%r&rkrYr!r/r!rZr\r)r!r3r!r?)r`r3r!rar#)rcr/r_r?r!r3N.rerfr_r?rgrar!rhrermr_r?rgrnr!roNNrerpr_r?rgrqr!rr)rOrPrQrR __slots____match_args__propertyrSabcabstractmethodrXr[r^r_setterrdtypingoverloadrkr%r%r%r&rs>     r) metaclassc @sTeZdZUdZdZdZededejej BZ ddddd d d d d Z de d<dWdXddZ dYddZdZdd Zd[d"d#Zed\d$d%Zejd]d'd%Zd^d)d*Zd_d-d.Zed`d/d0Zed`d1d2Zd`d3d4Zd`d5d6Zedad8d9Zdbd;d<Zdcd?d@ZdddCdDZdedfdFdGZej  HdgdhdMdNZ!ej  HdgdidRdNZ!  djdkdVdNZ!dS)lraThis 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. ) _prereleases_rangesrC _spec_versiona  (?: (?: # 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* compatibleequal not_equalless_than_equalgreater_than_equal less_than greater_than arbitrary)~=r:r;r9r8rArB===r _operatorsNr(r/r_r?r!racCs|j|s td||}|dr&|dd|dd}}n$|dr;|dd|dd}}n|dd|dd}}||f|_||_d|_d|_dS)aInitialize 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: rNr)rr:r;r9r8r+r ) _regex fullmatchrstrip startswithrCrrr)rVr(r_operatorversionr%r%r&__init__cs       zSpecifier.__init__rVersion | NonecCsD|jdur|jd|kr|jdSt|}|durdS||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rr )rVrversion_specifierr%r%r&_get_spec_versions  zSpecifier._get_spec_versionrcCs||}|dus J|S)zGet 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 ===). N)r)rVr spec_versionr%r%r&rGs  zSpecifier._require_spec_versionSequence[Interval]cCsP|jdur|jS|j}|j}|dkrt}n||d}t|||}||_|S)zConvert 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. Nrr@)rrrr rG removesuffixr )rVoprKresultrr%r%r& _to_rangess  zSpecifier._to_rangescCsX|jdur|jS|j\}}|dkrdS|dkr|drdS||}|dur)dS|jS)Nr;Fr:r@)rrCrDr is_prerelease)rVr version_strrr%r%r&r_s   zSpecifier.prereleasesr`cCs ||_dSr#)rrbr%r%r&r_ #tuple[tuple[str, str], bool | None]cC |j|jfSr#)rCrrUr%r%r& __getstate__ zSpecifier.__getstate__stater)cCsd|_d|_t|trQt|dkr%|\}}t|r%t|r%||_||_dSt|dkrQt|dt rQ|\}}| d}| dd}t|rQt|rQ||_||_dSt|t rq| d}| dd}t|rqt|rq||_||_dSt d|)Nr+r rCrinvalidzCannot restore Specifier from ) rrr,r-r.r0r4rCrdictrF TypeError)rVrr(r__ slot_dictr%r%r& __setstate__s2       zSpecifier.__setstate__cC |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrCrUr%r%r&r zSpecifier.operatorcCr)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rrUr%r%r&rrzSpecifier.versioncC8|jdur d|jnd}d|jjdt||dS)aTA representation of the Specifier that shows all internal state. >>> Specifier('>=1.0.0') =1.0.0')> >>> Specifier('>=1.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> Specifier('>=1.0.0', prereleases=True) =1.0.0', prereleases=True)> N, prereleases=rrA()>rr_ __class__rOr/rVr1r%r%r&__repr__ s zSpecifier.__repr__cCs dj|jS)zA 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{}{})formatrCrUr%r%r&rXs zSpecifier.__str__tuple[str, str]cCsF|j\}}|dks|dr||fS||}t||dkd}||fS)Nrr@r)strip_trailing_zero)rCrDrGr)rVrrrcanonical_versionr%r%r&_canonical_spec&s  zSpecifier._canonical_specrZcC t|jSr#)hashrrUr%r%r&r[4s zSpecifier.__hash__r\r3cCsPt|trz |t|}WntytYSwt||js"tS|j|jkS)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/rrNotImplementedrr]r%r%r&r^7s    zSpecifier.__eq__rc str | VersioncC ||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 rdrVrcr%r%r& __contains__T zSpecifier.__contains__UnparsedVersioncCs|jddkrtt|j|g|dSt|}|durdS|dur(t|j|j}|dur1|jr1dSt ||}|dur<|St | |S)a'Return 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:`~packaging.version.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 .. versionchanged:: 26.0 With ``prereleases=None``, a prerelease now matches. A single version has no alternatives, so the :pep:`440` rule to accept prereleases when nothing else satisfies the specifier applies. Earlier versions rejected it. An unparsable version now returns ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`. rrr_NF) rCr3listrkr rrr_rrNrr)rVrcr_r>matchr%r%r&rdis" zSpecifier.contains.rerfrgrhcCrir#r%rjr%r%r&rkrlzSpecifier.filterrmrnrocCrir#r%rjr%r%r&rkrlrprqrrcs\|dur t|j|j}|jdkr%|jfdd|D}t||St|||S)aFilter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`~packaging.version.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:`~packaging.version.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', ] >>> 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'}] .. versionchanged:: 26.1 Added the ``key`` parameter. Nrc3s4|]}tdur |n|kr|VqdSr#)r/lower.0rcrg spec_lowerr%r& s z#Specifier.filter..) rrr_rrr_apply_prereleases_filterr r)rVrer_rgmatchesr%rr&rks(    rN)r(r/r_r?r!ra)rr/r!r)rr/r!rr!rrvr`r?r!ra)r!rrr)r!rars)r!rrtru)rcrr!r3r#)rcrr_r?r!r3rwrxryrzr{)"rOrPrQrRr|_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rrrGrr~r_rrrrrrrXrr[r^rrdrrrkr%r%r%r&rsb \ #     !        8 rrprgrqr_rrcs2|dur t|S|rt|Sfdd|DS)zApply ``prereleases=`` handling to an already-matched iterable. ``None`` means PEP 440 default (buffer pre-releases until a final appears); ``True`` yields everything; ``False`` drops pre-releases. Nc3s:|]}tdur |n|dusjs|VqdSr#)r rrrgr>r%r&rs z,_apply_prereleases_filter..)_pep440_filter_prereleasesiter)rrgr_r%rr&rs  rc@sLeZdZdZdZ  dWdXd d ZdYddZedZddZej d[ddZd\ddZ d]ddZ d^ddZ d^ddZ d_d!d"Zd`d%d&Zdad(d)Zd_d*d+Zdbd-d.Zdcd0d1Zddd2d3Zddd4d5Zded7d8Zdfd9d:Zdgd;d<Zdgd=d>Zdgd?d@ZdhdCdDZ  didjdFdGZej  HdkdldMdNZej  HdkdmdRdNZ  didndVdNZdS)or aThis 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. )_canonicalized_has_arbitrary_is_unsatisfiablerr_specsrN specifiersstr | Iterable[Specifier]r_r?r!racCst|trdd|dD}ttt||_d|v|_nt||_tdd|jD|_t |jdk|_ d|_ d|_ ||_ dS) aInitialize 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. cSsg|] }|r|qSr%)rrsr%r%r& 3sz)SpecifierSet.__init__..,rcs|] }dt|vVqdSrNrTrr%r%r&r<z(SpecifierSet.__init__..r N)r,r/splitr-maprrranyr.rrrr)rVrr_split_specifiersr%r%r&rs    zSpecifierSet.__init__tuple[Specifier, ...]cCs,|jsttt|jtd|_d|_|jS)zBDeduplicate, sort, and cache specs for order-sensitive operations.rgT)rr-rfromkeyssortedrr/rUr%r%r&_canonical_specsFszSpecifierSet._canonical_specscCs6|jdur|jS|js dStdd|jDrdSdS)Ncss|]}|jVqdSr#rrr%r%r&r\sz+SpecifierSet.prereleases..T)rrrrUr%r%r&r_Ms zSpecifierSet.prereleasesr`cCs||_d|_dSr#)rrrbr%r%r&r_as )tuple[tuple[Specifier, ...], bool | None]cCrr#)rrrUr%r%r&rfrzSpecifierSet.__getstate__rr)cCsd|_d|_t|trt|dkr@|\}}t|tr@tdd|Dr@t|r@||_||_t|dk|_ t dd|D|_ dSt|dkrt|dt r|\}}| dd}| d}t|tritt|td }t|trtd d|Drt|r||_||_t|jdk|_ t d d|jD|_ dSt|t r| dd}| d}t|trtt|td }t|trtd d|Drt|r||_||_t|jdk|_ t d d|jD|_ dStd|)Nr+cs|]}t|tVqdSr#r,rrr%r%r&rwz,SpecifierSet.__setstate__..r csrrrTrr%r%r&r}rrr%rrcsrr#rrr%r%r&rrcsrrrTrr%r%r&rrcsrr#rrr%r%r&rrcsrrrTrr%r%r&rrz!Cannot restore SpecifierSet from )rrr,r-r.allr4rrrrrrrF frozensetrr/r)rVrspecsr_rrr%r%r&rlsd         zSpecifierSet.__setstate__r/cCr)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') =1.0.0')> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) =1.0.0', prereleases=True)> NrrrArrrrr%r%r&rs  zSpecifierSet.__repr__cCsddd|DS)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' rcss|]}t|VqdSr#rTrr%r%r&rz'SpecifierSet.__str__..)joinrrUr%r%r&rXs zSpecifierSet.__str__rZcCs t|Sr#)rrrUr%r%r&r[s zSpecifierSet.__hash__r\SpecifierSet | strcCst|tr t|}nt|tstSt}|j|j|_t|jdk|_|jp(|j|_|jdus5|j|jkr;|j|_|S|jdurF|j|_|St d)aReturn 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' =1.0.0')> >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') =1.0.0')> r NzFCannot combine SpecifierSets with True and False prerelease overrides.) r,r/r rrr.rrr ValueError)rVr\r=r%r%r&__and__s"   zSpecifierSet.__and__r3cCs:t|ttfrtt|}nt|tstS||kS)aWhether 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/rr rrr]r%r%r&r^s  zSpecifierSet.__eq__cCr)z7Returns the number of specifiers in this specifier set.)r.rrUr%r%r&__len__rzSpecifierSet.__len__Iterator[Specifier]cCr)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) [, =1.0.0')>] )rrrUr%r%r&__iter__s zSpecifierSet.__iter__rcCs,|jdur|jStdd|jD|_|jS)zIntersect all specifiers into a single sequence of version ranges. Empty when unsatisfiable. Callers must ensure ``self._specs`` is non-empty. Ncss|]}|VqdSr#)rrr%r%r&rrz+SpecifierSet._get_ranges..)rrrrUr%r%r& _get_rangess zSpecifierSet._get_rangescCs\|j}|dur |S|jsd|_dS| }|s|}|s)|jdur)t|}||_|S)aCheck 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 .. versionadded:: 26.1 NF)rrr _check_arbitrary_unsatisfiabler_r)rVcachedrr%r%r&is_unsatisfiables  zSpecifierSet.is_unsatisfiablecsdd|jD}|s dS|djtfdd|ddDr$d St|dj|jdur9dur9jr9d Sd d|jD}|sEdSdurKd Stfd d|D S) 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. cSsg|] }|jdkr|qSrrrr%r%r&rHz?SpecifierSet._check_arbitrary_unsatisfiable..Frc3s|] }|jkVqdSr#)rrr)firstr%r&rNsz>SpecifierSet._check_arbitrary_unsatisfiable..r NTcSsg|] }|jdkr|qSr rrr%r%r&r^rc3s|]}|VqdSr#rr) candidater%r&rfr)rrrrr r_rr)rVrstandardr%)rrr&r As$ z+SpecifierSet._check_arbitrary_unsatisfiableranges.VersionRangecCsddlm}||S)acReturn the :class:`~packaging.ranges.VersionRange` this set accepts. An empty set yields the full range; an unsatisfiable set yields the empty range. ``===`` specifiers contribute literal-string admission. >>> SpecifierSet(">=1.0,<2.0").to_range() .. versionadded:: 26.3 r ) VersionRange)rr_from_specifier_set)rVrr%r%r&to_rangehs zSpecifierSet.to_rangecCs*t|ts td|js|jrtddS)Nzexpected a SpecifierSetz+set relations do not support === specifiers)r,r rrrr]r%r%r&_check_relation_operandws  z$SpecifierSet._check_relation_operandcC||||S)a=Return whether every version matching this set also matches other. :raises ValueError: If either set uses ``===`` specifiers, or the two sets were given different ``prereleases`` arguments (unset on one side counts as different). :raises TypeError: If other is not a :class:`SpecifierSet`. >>> SpecifierSet(">=3.12,<3.13").is_subset(SpecifierSet(">=3.12")) True >>> SpecifierSet(">=3.12").is_subset(SpecifierSet(">=3.12,<3.13")) False .. versionadded:: 26.3 )rr is_subsetr]r%r%r&r} zSpecifierSet.is_subsetcCr)aReturn whether every version matching other also matches this set. :raises ValueError: If either set uses ``===`` specifiers, or the two sets were given different ``prereleases`` arguments (unset on one side counts as different). :raises TypeError: If other is not a :class:`SpecifierSet`. >>> SpecifierSet(">=3.12").is_superset(SpecifierSet(">=3.12,<3.13")) True .. versionadded:: 26.3 )rr is_supersetr]r%r%r&rs zSpecifierSet.is_supersetcCr)a.Return whether this set and other share no matching versions. :raises ValueError: If either set uses ``===`` specifiers, or the two sets were given different ``prereleases`` arguments (unset on one side counts as different). :raises TypeError: If other is not a :class:`SpecifierSet`. >>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.12")) True >>> SpecifierSet("<3.12").is_disjoint(SpecifierSet(">=3.11")) False .. versionadded:: 26.3 )rr is_disjointr]r%r%r&rrzSpecifierSet.is_disjointrcrcCr)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 rrr%r%r&rrzSpecifierSet.__contains__ installedc Cst|}|dur|r|jrd}|dus|jrt|ts|}n|}|durl|jsl|jdurl|jrl|jrA|dus?|durA|jdurAdS|j}|durg|jD]}t ||}|durXn|s]dSqKdS| }|_t ||St t |j|g|dS)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:`~packaging.version.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 .. versionchanged:: 26.0 With ``prereleases=None``, a prerelease now matches. A single version has no alternatives, so the :pep:`440` rule to accept prereleases when nothing else satisfies the specifiers applies. Earlier versions rejected it. An unparsable version now returns ``False`` instead of raising :exc:`~packaging.version.InvalidVersion`. NTFr)r rrr,rrErrrrNr rr3rrk) rVrcr_rr check_itemboundsr(rr%r%r&rds:(    zSpecifierSet.contains.rerfrgrhcCrir#r%rjr%r%r&rk$rlzSpecifierSet.filterrmrnrocCrir#r%rjr%r%r&rk,rlrprqrrcsz|dur |jdur |j}|jr7|jr%|jfdd|D}t||S|j}|dur0|}t|||St||S)aFilter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`~packaging.version.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:`~packaging.version.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', ] >>> 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'] .. versionchanged:: 26.0 Prerelease filtering now follows the PEP 440 recommendation of yielding prereleases only when no final release is present. .. versionchanged:: 26.1 Added the ``key`` parameter. Nc3s,|]tfddDrVqdS)c3s.|]}|jdur nddVqdS)NTrrr)rcrgr%r&rzs  z0SpecifierSet.filter...N)r)rrgr)rcr&rws z&SpecifierSet.filter..)r_rrrrr r )rVrer_rgrrr%r r&rk4s<   r)rrr_r?r!ra)r!rrvr)r!rrrsrt)r\rr!r ru)r!rr)r!r3)r!r)r\r)r!ra)r\r r!r3)rcrr!r3rz)rcrr_r?rr?r!r3rwrxryr{) rOrPrQrRr|rrr~r_rrrrrXr[rr^rrr r r rrrrrrrdrrrkr%r%r%r&r sV  ,     9     # '      X r reccsg}g}d}|D]:}t|dur|n||}|dur,|r!|Vn ||||q |js<|s8|EdHd}|Vq |sC||q |sM|EdHdSdS)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r appendr)rerg all_nonfinalarbitrary_strings found_finalrcr>r%r%r&rs0    r)r!r")r(r)r!r*)r1r)r!r2)r=rr>rr!r?)rrprgrqr_r?r!rr)rerprgrqr!rr)sZ  ,            V