o i=@sdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z ddl mZmZe eefZe dedZeeegefZd d d/ddZd0ddZGdddeZGdddejdZGdddeZedZd1d d!Zd2d#d$Zd3d&d'Z d4d+d,Z!Gd-d.d.eZ"dS)5z .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version ) annotationsN)CallableFinalIterableIteratorTypeVarUnion)Version_TrimmedReleaseUnparsedVersionVar)boundTstrip_trailing_zeroversion Version | strrboolreturnstrcCst|r tt|S|S)a Return a canonical form of a version as a string. >>> canonicalize_version('1.0.1') '1.0.1' Per PEP 625, versions may have multiple canonical forms, differing only by trailing zeros. >>> canonicalize_version('1.0.0') '1' >>> canonicalize_version('1.0.0', strip_trailing_zero=False) '1.0.0' Invalid versions are returned unaltered. >>> canonicalize_version('foo bar baz') 'foo bar baz' )rr )rrrW/home/ubuntu/.local/lib/python3.10/site-packages/ddtrace/vendor/packaging/specifiers.pycanonicalize_versionsrUnparsedVersionr cCst|ts t|}|SN) isinstancer )rrrr_coerce_version2s rc@seZdZdZdS)InvalidSpecifiera 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__rrrrr8src@seZdZejdddZejdddZejdd d Zeejd ddZ e j d!ddZ ejd"d#ddZ ej d"d$ddZ dS)% BaseSpecifierrrcCdS)z Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. Nrselfrrr__str__EzBaseSpecifier.__str__intcCr")zF Returns a hash value for this Specifier-like object. Nrr#rrr__hash__Lr&zBaseSpecifier.__hash__otherobjectrcCr")z Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. Nrr$r)rrr__eq__Rr&zBaseSpecifier.__eq__ bool | NonecCr")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. Nrr#rrr prereleases[r&zBaseSpecifier.prereleasesvalueNonecCr")zQSetter for :attr:`prereleases`. :param value: The value to set. Nrr$r/rrrr.dr&Nitemr.cCr")zR Determines if the given item is contained within this specifier. Nr)r$r2r.rrrcontainskr&zBaseSpecifier.containsiterableIterable[UnparsedVersionVar]Iterator[UnparsedVersionVar]cCr")z Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. Nr)r$r4r.rrrfilterqr&zBaseSpecifier.filterrrrr'r)r*rrrr-r/rrr0r)r2rr.r-rrr4r5r.r-rr6) rrrabcabstractmethodr%r(r,propertyr.setterr3r7rrrrr!Ds"    r!) metaclassc @sReZdZUdZdZdZedeedejej BZ dddd d d d d dZ de d<dUdVddZ edWddZejdXddZedYd d!ZedYd"d#ZdYd$d%ZdYd&d'ZedZd)d*Zd[d,d-Zd\d0d1Zd]d4d5Zd^d8d9Zd^d:d;Zd^dd?Zd^d@dAZd_dCdDZd_dEdFZd^dGdHZ d`dKdLZ!dadbdNdOZ" dadcdSdTZ#dS)d Specifiera?This class abstracts handling of version specifiers. .. tip:: It is generally not required to instantiate this manually. You should instead prefer to work with :class:`SpecifierSet` instead, which can parse comma-separated version specifiers (which is what package metadata contains). z8 (?P(~=|==|!=|<=|>=|<|>|===)) a (?P (?: # 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 .* | (?: # 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 (?:\+[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. (?=<>z===r _operatorsNspecrr.r-rr0cCsF|j|}|std||d|df|_||_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: operatorrN)_regexsearchrgroupstrip_spec _prereleases)r$rTr.matchrrr__init__s    zSpecifier.__init__rcCsR|jdur|jS|j\}}|dkr'|dkr |dr |dd}t|jr'dSdS)NrNrM.*TF)r[rZendswithr is_prerelease)r$rUrrrrr.s    zSpecifier.prereleasesr/cC ||_dSrr[r1rrrr.& cC |jdS)z`The operator of this specifier. >>> Specifier("==1.2.3").operator '==' rrZr#rrrrU* zSpecifier.operatorcCre)zaThe version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' r rfr#rrrr3rgzSpecifier.versioncCs8|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=rSrP()>)r[r. __class__rrr$prerrr__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{}{})formatrZr#rrrr%Ns zSpecifier.__str__tuple[str, str]cCs*t|jd|jddkd}|jd|fS)Nr rrLr)rrZ)r$canonical_versionrrr_canonical_specXs  zSpecifier._canonical_specr'cC t|jSr)hashrrr#rrrr(` zSpecifier.__hash__r)r*cCsPt|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 )rrrkrNotImplementedrrr+rrrr,cs    zSpecifier.__eq__opCallableOperatorcCst|d|j|}|S)N _compare_)getattrrR)r$rwoperator_callablerrr _get_operatorszSpecifier._get_operator prospectiver cCsHttttt|dd}|d7}|d||o#|d||S)Nr^rOrM) _version_joinlist itertools takewhile_is_not_suffix_version_splitr|)r$r}rTprefixrrr_compare_compatibles zSpecifier._compare_compatiblec Cs|dr1t|jdd}t|dddd}t|}t|}t||\}}|dt|} | |kSt|} | js=t|j}|| kS)Nr^Frr_)r`rpublicr _pad_versionlenr local) r$r}rTnormalized_prospectivenormalized_spec split_specsplit_prospectivepadded_prospective_shortened_prospective spec_versionrrr_compare_equals  zSpecifier._compare_equalcCs||| Sr)rr$r}rTrrr_compare_not_equalszSpecifier._compare_not_equalcCst|jt|kSrr rrrrr_compare_less_than_equalz"Specifier._compare_less_than_equalcCst|jt|kSrrrrrr_compare_greater_than_equalrz%Specifier._compare_greater_than_equalspec_strcCs<t|}||ks dS|js|jrt|jt|jkrdSdSNFT)r ra base_versionr$r}rrTrrr_compare_less_thans zSpecifier._compare_less_thancCs^t|}||ks dS|js|jrt|jt|jkrdS|jdur-t|jt|jkr-dSdSr)r is_postreleaserrrrrr_compare_greater_thans  zSpecifier._compare_greater_thancCst|t|kSr)rlowerrrrr_compare_arbitraryszSpecifier._compare_arbitraryr2 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") False >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True r3r$r2rrr __contains__  zSpecifier.__contains__rcCs<|dur|j}t|}|jr|sdS||j}|||jS)alReturn whether or not the item is contained in this specifier. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this Specifier. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> 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") False >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") True >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) True NF)r.rrar|rUr)r$r2r.normalized_itemr{rrrr3s   zSpecifier.containsr4r5r6ccsd}g}d|dur |ndi}|D]"}t|}|j|fi|r3|jr.|s.|js.||qd}|Vq|s@|rB|D] }|Vq:dSdSdS)aOFilter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(Specifier().contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> 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'] Fr.NT)rr3rar.append)r$r4r.yieldedfound_prereleaseskwrparsed_versionrrrr7Ks* zSpecifier.filterrSN)rTrr.r-rr0)rrr<r8)rrpr9r:)rwrrrx)r}r rTrrr)r}r rrrr)r2rrrr)r2rr.r-rrr=)$rrrr _operator_regex_str_version_regex_strrecompileVERBOSE IGNORECASErVrR__annotations__r]r@r.rArUrrnr%rrr(r,r|rrrrrrrrrr3r7rrrrrC{sZ  ^               (       -rCz^([0-9]+)((?:a|b|c|rc)[0-9]+)$ list[str]cCs^g}|d\}}}||pd|dD]}t|}|r'||q||q|S)aSplit version into components. The split components are intended for version comparison. The logic does not attempt to retain the original version string, so joining the components back with :func:`_version_join` may not produce the original version string. !0.) rpartitionrsplit _prefix_regexrWextendgroups)rresultepochrrestr2r\rrrrs  r componentscCs|^}}|dd|S)zJoin split version components into a version string. This function assumes the input came from :func:`_version_split`, where the first component must be the epoch (either empty or numeric), and all other components numeric. rr)join)rrrrrrrsrsegmentcstfdddD S)Nc3s|]}|VqdSr) startswith).0rrrr s  z!_is_not_suffix..)devabrcpost)anyrrrrrs  rleftrighttuple[list[str], list[str]]c Csgg}}|ttdd||ttdd|||t|dd||t|dd|ddgtdt|dt|d|ddgtdt|dt|dttj|ttj|fS)NcS|Srisdigitxrrrz_pad_version..cSrrrrrrrrrrr r) rrrrrinsertmaxchain from_iterable)rr left_split right_splitrrrrs ,,rc@seZdZdZ  d1d2d d Zed3d d Zejd4dd Zd5ddZd5ddZ d6ddZ d7ddZ d8ddZ d6d d!Z d9d#d$Zd:d'd(Z  d;dd/d0ZdS)? SpecifierSetzThis 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. rSN specifiersstr | Iterable[Specifier]r.r-rr0cCsDt|trdd|dD}ttt||_nt||_||_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)rYrsrrr sz)SpecifierSet.__init__..,N)rrr frozensetmaprC_specsr[)r$rr.split_specifiersrrrr]s   zSpecifierSet.__init__cCs.|jdur|jS|js dStdd|jDS)Ncss|]}|jVqdSrr.rrrrrsz+SpecifierSet.prereleases..)r[rrr#rrrr.s zSpecifierSet.prereleasesr/rcCrbrrcr1rrrr.rdrcCs.|jdur d|jnd}dt||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)> NrhrSz>> 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)rrrrrr*sz'SpecifierSet.__str__..)rsortedrr#rrrr%s zSpecifierSet.__str__r'cCrsr)rtrr#rrrr(,ruzSpecifierSet.__hash__r)SpecifierSet | strcCst|tr t|}nt|tstSt}t|j|jB|_|jdur-|jdur-|j|_|S|jdur=|jdur=|j|_|S|j|jkrI|j|_|Std)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')> NzFCannot combine SpecifierSets with True and False prerelease overrides.)rrrrvrrr[ ValueError)r$r) specifierrrr__and__/s$    zSpecifierSet.__and__r*cCs6t|ttfrtt|}nt|tstS|j|jkS)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 )rrrCrrvrr+rrrr,Ns   zSpecifierSet.__eq__cCrs)z7Returns the number of specifiers in this specifier set.)rrr#rrr__len__hrdzSpecifierSet.__len__Iterator[Specifier]cCrs)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')>] )iterrr#rrr__iter__ls zSpecifierSet.__iter__r2rcCr)arReturn 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") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True rrrrrrvrzSpecifierSet.__contains__ installedcs\tts tdur|jsjrdS|r!jr!tjtfdd|jDS)aReturn whether or not the item is contained in this SpecifierSet. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this SpecifierSet. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> 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") False >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True NFc3s|] }|jdVqdS)rNrrr2r.rrrsz(SpecifierSet.contains..)rr r.rarallr)r$r2r.rrrrr3s    zSpecifierSet.containsr4r5r6cCs|dur|j}|jr|jD] }|j|t|d}q t|Sg}g}|D]}t|}|jr6|s6|s5||q#||q#|sH|rH|durHt|St|S)a.Filter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> 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"])) [] >>> 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'] 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'] Nr)r.rr7rrrrar)r$r4r.rTfilteredrr2rrrrr7s$,    zSpecifierSet.filterr)rrr.r-rr0r;r<r8r9)r)rrrr:)rr)r2rrr)NN)r2rr.r-rr-rrrr=)rrrr r]r@r.rArnr%r(rr,rrrr3r7rrrrrs, &          :r)rrrrrr)rrrr )rrrr)rrrr)rrrr)rrrrrr)#r __future__rr>rrtypingrrrrrrrr r rrr rrxrrrrABCMetar!rCrrrrrrrrrrrs4      7