a 紫j>@sUdZddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZddlmZddlmZerddlZdd lmZmZmZejd krdd lm Z n dd l!m Z dd l"m#Z#dd l m$Z$gdZ%ddddZ&dddddZ'dddddZ(e dZ)e ee*fZ+e de+dZ,ej-ej.ej/ej0dZ1d e2d!<d"d#d$d%d&d'Z3Gd(d)d)e4Z5Gd*d+d+ej6d,Z7Gd-d"d"e7Z8d.d/d$d0d1d2d3Z9Gd4d5d5e7Z:d.d/d0d6d7d8Z;dS)9z .. 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 SpecifierSetz list[str]returncCstSN)__all__r%r%S/var/www/html/laksyashrimp/venv/lib/python3.9/site-packages/packaging/specifiers.py__dir__<sr'objectzTypeGuard[tuple[str, str]])specr"cCs2t|to0t|dko0t|dto0t|dtS)Nrr ) isinstancetuplelenstr)r)r%r%r&_validate_spec@s    r/zTypeGuard[bool | None])prer"cCs|dupt|tSr#)r+bool)r0r%r%r& _validate_preIsr2TUnparsedVersionVar)bound)>=<===!=z-dict[str, Callable[[Version, Version], bool]]_DIRECT_COMPARE_OPSrr bool | None) specifierparsedr"cCs|j\}}|ds|jdur"dSt|}|durD||||S|dvr||}|j|jksvt|jt|jkr|dkr||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)<>r?) _specendswithlocalr:get_require_spec_versionepochrrelease)r<r=Zop_strver_strZdirect_compareZspec_vr%r%r& _fast_match]s   rIc@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@seZdZdZdZdZeddddZej dddd Z ej d dd d Z ej d ddddZ eej ddddZ e jdddddZ ej d*ddddddZejd+dddddd d!Zejd,d"dd#d$dd%d!Zej d-d&dd'd(dd)d!ZdS).rzO Abstract base class for :class:`Specifier` and :class:`SpecifierSet`. r%)_strr.r!cCst|S)z Internal property for match_argsr.selfr%r%r&rNszBaseSpecifier._strcCsdS)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nr%rPr%r%r&__str__szBaseSpecifier.__str__intcCsdS)zF Returns a hash value for this Specifier-like object. Nr%rPr%r%r&__hash__szBaseSpecifier.__hash__r(r1otherr"cCsdS)z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nr%rQrVr%r%r&__eq__szBaseSpecifier.__eq__r;cCsdS)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%rPr%r%r& prereleasesszBaseSpecifier.prereleasesNonevaluer"cCsdS)zQSetter for :attr:`prereleases`. :param value: The value to set. Nr%rQr\r%r%r&rYsNitemrYr"cCsdS)zR Determines if the given item is contained within this specifier. Nr%)rQr_rYr%r%r&containsszBaseSpecifier.contains.Iterable[UnparsedVersionVar]Iterator[UnparsedVersionVar]iterablerYkeyr"cCsdSr#r%rQrdrYrer%r%r&filterszBaseSpecifier.filter Iterable[T]Callable[[T], UnparsedVersion] Iterator[T]cCsdSr#r%rfr%r%r&rgs Iterable[Any]'Callable[[Any], UnparsedVersion] | None Iterator[Any]cCsdS)z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr%rfr%r%r&rgs)N)N.)N.)NN)rJrKrLrM __slots__Z__match_args__propertyrNabcabstractmethodrRrTrXrYsetterr`typingoverloadrgr%r%r%r&rs<r) metaclassc @seZdZUdZdZdZededejej BZ ddddd d d d d Z de d<dVddddddZ dddddZdddddZdd d!d"Zedd d#d$Zejddd%d&d$Zd'd d(d)Zd*dd+d,d-Zedd d.d/Zedd d0d1Zdd d2d3Zdd d4d5Zed6d d7d8Zd9d d:d;Zd*dd?Zd@d=|<|>) \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)~=r8r9r7r6r?r@===r _operatorsNr.r;rZ)r)rYr"cCs|j|std||}|drL|dd|dd}}nH|drv|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)rr8r9r7r6r*r ) _regex fullmatchrstrip startswithrArvrxrw)rQr)rYoperatorversionr%r%r&__init__cs      zSpecifier.__init__zVersion | None)rr"cCsD|jdur"|jd|kr"|jdSt|}|dur6dS||f|_|S)zDOne element cache, as only one spec Version is needed per Specifier.Nrr )rxr )rQrZversion_specifierr%r%r&_get_spec_versions  zSpecifier._get_spec_versionrcCs||}|dusJ|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)rQr spec_versionr%r%r&rEs  zSpecifier._require_spec_versionSequence[Interval]r!cCsP|jdur|jS|j}|j}|dkr*t}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>)rwrrr rE removesuffixr )rQoprHresultrr%r%r& _to_rangess  zSpecifier._to_rangescCsX|jdur|jS|j\}}|dkr&dS|dkr<|dr)rvrArBr is_prerelease)rQr version_strrr%r%r&rYs   zSpecifier.prereleasesr[cCs ||_dSr#)rvr]r%r%r&rYsz#tuple[tuple[str, str], bool | None]cCs |j|jfSr#)rArvrPr%r%r& __getstate__szSpecifier.__getstate__r(stater"cCsd|_d|_t|trt|dkrJ|\}}t|rJt|rJ||_||_dSt|dkrt|dt r|\}}| d}| dd}t|rt|r||_||_dSt|t r| d}| dd}t|rt|r||_||_dSt d|dS)Nr*r rArvinvalidzCannot restore Specifier from ) rxrwr+r,r-r/r2rArvdictrD TypeError)rQrr)rY_ slot_dictr%r%r& __setstate__s2       zSpecifier.__setstate__cCs |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrArPr%r%r&rszSpecifier.operatorcCs |jdS)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rrPr%r%r&rszSpecifier.versioncCs8|jdurd|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=rr?()>rvrY __class__rJr.rQr0r%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{}{})formatrArPr%r%r&rRszSpecifier.__str__ztuple[str, str]cCsF|j\}}|dks|dr$||fS||}t||dkd}||fS)Nrr>r)Zstrip_trailing_zero)rArBrEr)rQrrrZcanonical_versionr%r%r&_canonical_spec&s  zSpecifier._canonical_specrScCs t|jSr#)hashrrPr%r%r&rT4szSpecifier.__hash__r1rUcCsRt|tr6z|t|}WqFty2tYS0nt||jsFtS|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.rrNotImplementedrrWr%r%r&rX7s    zSpecifier.__eq__z str | Versionr_r"cCs ||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 r`rQr_r%r%r& __contains__TszSpecifier.__contains__UnparsedVersionr^cCs|jddkr&tt|j|g|dSt|}|dur:dS|durPt|j|j}|durb|jrbdSt ||}|durx|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`. rrrYNF) rAr1listrgr rrvrYrrIrr)rQr_rYr=matchr%r%r&r`is" zSpecifier.contains.rarbrccCsdSr#r%rfr%r%r&rgszSpecifier.filterrhrirjcCsdSr#r%rfr%r%r&rgsrkrlrmcs\|durt|j|j}|jdkrJ|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. Nrc3s2|]*}tdur|n|kr|VqdSr#)r.lower.0r_reZ spec_lowerr%r& s z#Specifier.filter..) rrvrYrrr_apply_prereleases_filterr r)rQrdrYrematchesr%rr&rgs(    )rN)N)N.)N.)NN)"rJrKrLrMrnZ_specifier_regex_strrecompileVERBOSE IGNORECASErr__annotations__rrrErrorYrrrrrrrrRrrTrXrr`rsrtrgr%r%r%r&rs` \ #  !  8 rkrlrm)rrerYr"cs2|durt|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. Nc3s8|]0}tdur|n|dus,js|VqdSr#)r rrrer=r%r&rs z,_apply_prereleases_filter..)_pep440_filter_prereleasesiter)rrerYr%rr&rs   rc@seZdZdZdZdUddddd d Zd d d dZedd ddZej dddddZdd ddZ dddddZ dd ddZ dd ddZ dd d d!Zd"dd#d$d%Zdd&d#d'd(Zdd d)d*Zd+d d,d-Zd.d d/d0Zd&d d1d2Zd&d d3d4Zd5d d6d7Zddd#d8d9Zdd&d#d:d;Zdd&d#dd?Zd@d&dAdBdCZdVd@ddd&dDdEdFZejdWdHdddIdJdKdLZejdXdMddNdOdJdPdLZdYdQddRdSdJdTdLZdS)Zr 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_unsatisfiablervrw_specsrNzstr | Iterable[Specifier]r;rZ) specifiersrYr"cCst|tr:dd|dD}ttt||_d|v|_n t||_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& 3z)SpecifierSet.__init__..,rcss|]}dt|vVqdSrNrOrr%r%r&r<rz(SpecifierSet.__init__..r N)r+r.splitr,maprrranyr-rrrwrv)rQrrYsplit_specifiersr%r%r&rs   zSpecifierSet.__init__ztuple[Specifier, ...]r!cCs,|js&ttt|jtd|_d|_|jS)zBDeduplicate, sort, and cache specs for order-sensitive operations.reT)rr,rfromkeyssortedrr.rPr%r%r&_canonical_specsFszSpecifierSet._canonical_specscCs6|jdur|jS|jsdStdd|jDr2dSdS)Ncss|] }|jVqdSr#rrr%r%r&r\rz+SpecifierSet.prereleases..T)rvrrrPr%r%r&rYMs zSpecifierSet.prereleasesr[cCs||_d|_dSr#)rvrr]r%r%r&rYasz)tuple[tuple[Specifier, ...], bool | None]cCs |j|jfSr#)rrvrPr%r%r&rfszSpecifierSet.__getstate__r(rcCsd|_d|_t|tr8t|dkr|\}}t|trtdd|Drt|r||_||_t|dk|_ t dd|D|_ dSt|dkr8t|dt r8|\}}| dd}| d}t|trtt|td }t|tr8td d|Dr8t|r8||_||_t|jdk|_ t d d|jD|_ dSt|t r| dd}| d}t|trvtt|td }t|trtd d|Drt|r||_||_t|jdk|_ t d d|jD|_ dStd|dS)Nr*css|]}t|tVqdSr#r+rrr%r%r&rwrz,SpecifierSet.__setstate__..r css|]}dt|vVqdSrrOrr%r%r&r}rrr%rvrcss|]}t|tVqdSr#rrr%r%r&rrcss|]}dt|vVqdSrrOrr%r%r&rrcss|]}t|tVqdSr#rrr%r%r&rrcss|]}dt|vVqdSrrOrr%r%r&rrz!Cannot restore SpecifierSet from )rwrr+r,r-allr2rrvrrrrrD frozensetrr.r)rQrspecsrYrrr%r%r&rlsd         zSpecifierSet.__setstate__r.cCs8|jdurd|jnd}d|jjdt||dS)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)> Nrrr?rrrrr%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#rOrr%r%r&rrz'SpecifierSet.__str__..)joinrrPr%r%r&rRs zSpecifierSet.__str__rScCs t|Sr#)rrrPr%r%r&rTszSpecifierSet.__hash__zSpecifierSet | strrUcCst|trt|}nt|ts"tSt}|j|j|_t|jdk|_|jpP|j|_|jdusj|j|jkrt|j|_n|jdur|j|_nt d|S)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-rrrv ValueError)rQrVr<r%r%r&__and__s      zSpecifierSet.__and__r1cCs:t|ttfrtt|}nt|ts*tS||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 rrrWr%r%r&rXs  zSpecifierSet.__eq__cCs t|jS)z7Returns the number of specifiers in this specifier set.)r-rrPr%r%r&__len__szSpecifierSet.__len__zIterator[Specifier]cCs t|jS)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')>] )rrrPr%r%r&__iter__szSpecifierSet.__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..)rwrrrPr%r%r& _get_rangess zSpecifierSet._get_rangescCs\|j}|dur|S|js"d|_dS| }|s8|}|sR|jdurRt|}||_|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_unsatisfiablerYr)rQcachedrr%r%r&is_unsatisfiables  zSpecifierSet.is_unsatisfiablecsdd|jD}|sdS|djtfdd|ddDrHd St|dj|jdurrdurrjrrd Sd d|jD}|sdSdurd 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&rHrz?SpecifierSet._check_arbitrary_unsatisfiable..Frc3s|]}|jkVqdSr#)rrr)firstr%r&rNrz>SpecifierSet._check_arbitrary_unsatisfiable..r NTcSsg|]}|jdkr|qSrrrr%r%r&r^rc3s|]}|VqdSr#rr) candidater%r&rfr)rrrrr rYrr)rQrstandardr%)rrr&rAs(z+SpecifierSet._check_arbitrary_unsatisfiablezranges.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)rrZ_from_specifier_set)rQrr%r%r&to_rangehs zSpecifierSet.to_rangecCs*t|tstd|js|jr&tddS)Nzexpected a SpecifierSetz+set relations do not support === specifiers)r+r rrrrWr%r%r&_check_relation_operandws  z$SpecifierSet._check_relation_operandcCs||||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_subsetrWr%r%r&r}s zSpecifierSet.is_subsetcCs||||S)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_supersetrWr%r%r&rs zSpecifierSet.is_supersetcCs||||S)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_disjointrWr%r%r&rs zSpecifierSet.is_disjointrrcCs ||S)aqReturn whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") True >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") True >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") True >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True rrr%r%r&rszSpecifierSet.__contains__)r_rY installedr"c Cst|}|dur|r|jrd}|dus6|jr>> 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+rrCrrvrwrIrrr1rrg) rQr_rYrrZ check_itemZboundsr)rr%r%r&r`sD(   zSpecifierSet.contains.rarbrccCsdSr#r%rfr%r%r&rg$szSpecifierSet.filterrhrirjcCsdSr#r%rfr%r%r&rg,srkrlrmcsz|dur|jdur|j}|jrn|jrJ|jfdd|D}t||S|j}|dur`|}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,|]$}|jdurnddVqdS)NTrrr)r_rer%r&rzsz0SpecifierSet.filter...N)r)rrer)r_r&rws z&SpecifierSet.filter..)rYrrrrwrr )rQrdrYrerrr%rr&rg4s<  )rN)NN)N.)N.)NN) rJrKrLrMrnrrrorYrrrrrrRrTrrXrrrrrrrrrrrr`rsrtrgr%r%r%r&r sT ,9    #'X r )rdrer"ccsg}g}d}|D]t}t|dur"|n||}|durV|r@|Vq||||q|jsv|sn|EdHd}|Vq|s||q|s|EdHdS)z?Filter per PEP 440: exclude prereleases unless no finals exist.FNT)r appendr)rdreZ all_nonfinalZarbitrary_stringsZ found_finalr_r=r%r%r&rs*    r)sX  ,          V