.dghybdZdZddlZddlZddlZd dZGddZd dZdZGd d Z y) z Provide consistent and up-to-date ``__version__`` strings for Python packages. See https://github.com/holoviz/autover for more information. zJean-Luc StevensNc\i}tjdk(rtj|d<tj|ftj tj |d|}d|j D\}}|jdk7st|dkDrt|j||S)Nnt creationflags)stdoutstderrcwdc3jK|]+}t|jj-ywN)strdecodestrip).0ss -lib/python3.12/site-packages/param/version.py zrun_cmd..!s&I6HS_**,6Hs13r) osname subprocessCREATE_NO_WINDOWPopenPIPE communicate returncodelen Exception)argsrkwargsprocoutputerrors rrun_cmdr!s F ww$","="=   D &#-?? # &% &DJd6F6F6HIMFE  !s5zA~// MceZdZdZfdZ ddZedZedZedZ edZ edZ d Z dd Z d Zdd Zd ZdZdZdZddZe ddZedZe ddZxZS)Versiona A simple approach to Python package versioning that supports PyPI releases and additional information when working with version control. When obtaining a package from PyPI, the version returned is a string-formatted rendering of the supplied release tuple. For instance, release (1,0) tagged as ``v1.0`` in the version control system will return ``1.0`` for ``str(__version__)``. Any number of items can be supplied in the release tuple, with either two or three numeric versioning levels typical. During development, a command like ``git describe`` will be used to compute the number of commits since the last version tag, the short commit hash, and whether the commit is dirty (has changes not yet committed). Version tags must start with a lowercase 'v' and have a period in them, e.g. v2.0, v0.9.8 or v0.1 and may include the PEP440 prerelease identifiers of 'a' (alpha) 'b' (beta) or 'rc' (release candidate) allowing tags such as v2.0.a3, v0.9.8.b3 or v0.1.rc5. Also note that when version control system (VCS) information is used, the number of commits since the last version tag is determined. This approach is often useful in practice to decide which version is newer for a single developer, but will not necessarily be reliable when comparing against a different fork or branch in a distributed VCS. For git, if you want version control information available even in an exported archive (e.g. a .zip file from GitHub), you can set the following line in the .gitattributes file of your project:: __init__.py export-subst Note that to support pip installation directly from GitHub via git archive, a .version file must be tracked by the repo to supply the release number (otherwise only the short SHA is available). The PEP440 format returned is [N!]N(.N)*[{a|b|rc}N][.postN+SHA] where everything before .postN is obtained from the tag, the N in .postN is the number of commits since the last tag and the SHA is obtained via git describe. This later portion is only shown if the commit count since the last tag is non zero. Instead of '.post', an alternate valid prefix such as '.rev', '_rev', '_r' or '.r' may be supplied. c dd|vr|d d|vr|dd|vr tdi|St| |S)Nreleasedev commit_count)OldDeprecatedVersionsuper__new__)clskw __class__s rr,zVersion.__new__YsJ O9 9 RKBuI1 b '-"- -7?3' 'r"c ||_||_|d|vr td||_||j drdn||_d|_d|_d|_d|_ ||_ ||_ ||_ y)a1 :release: Release tuple (corresponding to the current VCS tag) :commit Short SHA. Set to '$Format:%h$' for git archive support. :fpath: Set to ``__file__`` to access version control information :reponame: Used to verify VCS repository name. Nr(znWARNING: param.Version now supports PEP440 and a new tag based workflow. See param/version.py for more details$FormatF) fpath_expected_commitprintexpected_release startswith_commit _commit_count_release_dirty _prereleasearchive_commitreponamecommit_count_prefix)selfr&r2commitr=r>r<rs r__init__zVersion.__init__ds &  .F": C D ' &&2C2CI2NtU[ !  +  #6 r"c6|jjS)z} Either None or one of 'aN' (alpha), 'bN' (beta) or 'rcN' (release candidate) where N is an integer. )fetchr;r?s r prereleasezVersion.prereleases zz|'''r"c6|jjSzReturn the release tuplerCr9rDs rr&zVersion.releasezz|$$$r"c6|jjSzEA specification for this particular VCS version, e.g. a short git SHArCr7rDs rr@zVersion.commitzz|###r"c6|jjSz3Return the number of commits since the last releaserCr8rDs rr(zVersion.commit_countzz|)))r"c6|jjSz5True if there are uncommited changes, False otherwiserCr:rDs rdirtyz Version.dirtyzz|"""r"c|j|S|j|_|js|j|_|SdD]} |j ||S|S#t $rY&wxYwz Returns a tuple of the major version together with the appropriate SHA and dirty bit (for development version only). )gitzgit.cmdzgit.exer9r5r2r3r7 git_fetchOSErrorr?cmds rrCz Version.fetch{ == $K-- zz00DLK1C s# 1    A A('A(cP|j}d} |jt|ddgtjj |j d|jzdzd|jzdzg}tfd|Ds$ |j}||j||:t|dd d d d gtjj |j }|r|S |j|y#t$rY^wxYw#t$r} |j}||j||jrd|_ |r|cYd}~S|r||_Yd}~y#t$r'|jd dk(r td|cYcYd}~SwxYwd}~wwxYw)Nremote-vr/.git c3&K|]}|v ywr r))rmremotess rrz$Version.git_fetch..s>A1<describe--long--matchzv[0-9]*.[0-9]*.[0-9]*--dirty0fatal: No names found, cannot describe anything./Cannot find any git version tags of format v*.*)r7r=r!rpathdirnamer2any_output_from_file_update_from_vcsr _known_staler8r\r)r?r^ as_stringcommit_argumentr repo_matchese1rjs @rr[zVersion.git_fetchs,,* }}("3$"7&(ggoodjj&AC #dmm 3f <!$dmm 3c 9 ; >>>+!%!7!7!9!- 11&9~ #z8Y"99"F%'WW__TZZ%@B-y, f%9%*d*  //1%))&1$$&)-D&Vm##2DL 771:!SS#$UVV   sfA;D #D0?D D DDD F%=E-F% E--(FF F%FF  F%c|jd}n |j}|jduxr-|jjd xr|j|k7}|rd|_|S)z The commit is known to be from a file (and therefore stale) if a SHA is supplied by git archive and doesn't match the parsed commit. Nr1)rvr@r<r6r8)r?r@ known_stales rrxzVersion._known_stalesu  ! ! # +F[[F**$69#22==iHH9..&8  T*r"cX tjjtjj|jd}t |5}t j|jj|dcdddS#1swYyxYw#t$rYywxYw)z Read the version from a .version file that may exist alongside __init__.py. This file can be generated by piping the following output to file: git describe --long --match v*.* .versionN) rrsjoinrtr2openjsonloadsreadgetr)r?entryvfilefs rrvzVersion._output_from_fileso GGLL!.s: "c"g rU) splitr;tupler9rr8r r7r:)r?rr dot_splitprefix prefix_splits rrwzVersion._update_from_vcssqr   %!HNN3' $F2&(}226: #)L,<#< ,Q " %: ::  q]58AB<( Ry')  r"c|j}|j|s|jd}|dS|S|j4|r2|jd}||Sdj|jSdj d|jD}|j dn |j }|jd k(r|js||zS|j}|jrd nd}d}|rd }|j}|dk7r|jd z}n3|jd vr#|jt|jz}nd}||||dnd|z||g} dj | S)i Version in x.y.z string format. Does not include the "v" prefix of the VCS version tags, for pip compatibility. If the commit count is non-zero or the repository is dirty, the string representation is equivalent to the output of:: git describe --long --match v*.* --dirty (with "v" prefix removed). extracted_directory_tag)rNonez0.0.0+g{SHA}-gitarchive)SHArc32K|]}t|ywr r rs rrz"Version.__str__...:\r3r7\rr-dirtyz -gitarchive0)rNz+g) rxr&rvformatr<rrEr(rUr@r>r ) r?r~rr&rEr@rUr< postcount componentss r__str__zVersion.__str__s{'') <<  &*&<&.L7,BB,r)rr&rDs rabbrevzVersion.abbrevJsxx7$,,777r"cb|r|t|k7r td|jr td|j$|j|jk7r td|j dk7r td|j '|j jds tdyy) 7 Check that the version information is consistent with the VCS before doing a release. If supplied with a string version, this is also checked against the current version. Should be called from setup.py with the declared package version before releasing to PyPI. 7Supplied string version does not match current version.#Current working directory is dirty.N4Declared release does not match current release tag.r1Please update the VCS version tag before release.r13Declared release does not match the VCS version tag)r rrUr5r&r(r3r6r?string_versions rverifyzVersion.verifyNs nD 9UV V ::AB B  ,AVAV1VRS S   q OP P  ! ! -))44i@QR RA .r"cZ||n|}gd}||vrtd|ztjj||d}t |||} |r| j d} n t | } | jr|dk(r td| jr|d k(r| jd d S| S) a Helper for use in setup.py to get the version from the .version file (if available) or more up-to-date information from git describe (if available). Assumes the __init__.py will be found in the directory {reponame}/__init__.py relative to setup.py unless pkgname is explicitly specified in which case that name is used instead. If describe is True, the raw string obtained from git described is returned which is useful for updating the .version file. The dirty policy can be one of 'report', 'strip', 'raise'. If it is 'report' the version string may end in '-dirty' if the repository is in a dirty state. If the policy is 'strip', the '-dirty' suffix will be stripped out if present. If the policy is 'raise', an exception is raised if the repository is in a dirty state. This can be useful if you want to make sure packages are not built from a dirty repository state. )raisereportr z,get_setup_version dirty policy must be in %rz __init__.py)r2r=r<T)ryrzRepository is in a dirty state.r rr) AssertionErrorrrsrr$r[r rUreplace) r- setup_pathr=rlrUpkgnamer<policiesr2versionvstrings rget_setup_versionzVersion.get_setup_versionhs,&o(7.   !ORZ!Z[ [ Z-@X ''$'7G'lG ==Ug- !BC C ]]ug~??8R0 0Nr"ctjj|d}|dz}|j|r|t |d}|dvrd|vr|Sy)Nrr)rmastermainr)rrsrr6r)r-rr= setup_dirrtags rextract_directory_tagzVersion.extract_directory_tagsWGGMM*-b1 C    'CKL)C00cSj r"ci}d}||n|} tj||d|||}|||d<|xtj||}|||d< t t j j||dd5} | jtjd|idddtj||d||||d < t t j j||dd5} | jtj|ddd|d S#t$rYwxYw#1swYxYw#t$rtdYwxYw#1swYDxYw#t$rtdY|d SwxYw) NT)rlrUrr< git_describerrwz6Error in setup_version: could not write .version file.Fversion_string) r$rrrrrrsrwriterdumpsr4) r-rr=r<rrUinforrrs r setup_versionzVersion.setup_versions %o(7 #55j6>?CEES 6UL''3^$  &-&C&CJPX&Y #&22I./ P"'',,z7JGMQRGGDJJ(ABY'Z[\N #*";";JCGK&&R@D*2)&)&r"r$cddl}||n|}||jdtjtj j tj j||||S)a Helper for use in setup.py to get the current version from either git describe or the .version file (if available). Set pkgname to the package name if it is different from the repository name. To ensure git information is included in a git archive, add setup.py to .gitattributes (in addition to __init__): ``` __init__.py export-subst setup.py export-subst ``` Then supply "$Format:%h$" for archive_commit. rNzNNo archive commit available; git archives will not contain version information)rr<)warningswarnr$rrrsrtabspath)locationr=rr<rs rrrse"!/hwG fg  1J!KH]duC DDr"cddl}ddl}d}d}|j}|j||j dd}||j vr|j |dd|in|}d}|d z}|j D]5} | j |s|jd | jd }7t|||| S) a  As get_setup_version(), but configure via setup.cfg. If your project uses setup.cfg to configure setuptools, and hence has at least a "name" key in the [metadata] section, you can set the version as follows: ``` [metadata] name = mypackage version = attr: autover.version.get_setup_version2 ``` If the repository name is different from the package name, specify `reponame` as a [tool:autover] option: ``` [tool:autover] reponame = mypackage ``` To ensure git information is included in a git archive, add setup.cfg to .gitattributes (in addition to __init__): ``` __init__.py export-subst setup.cfg export-subst ``` Then add the following to setup.cfg: ``` [tool:autover.configparser_workaround.archive_commit=$Format:%h$] ``` The above being a section heading rather than just a key is because setuptools requires % to be escaped with %, or it can't parse setup.cfg...but then git export-subst would not work. rNz setup.cfgz tool:autovermetadatarr=)varsz'.configparser_workaround.archive_commitz.*=\s*(\S*)\s*rp)r=rr<) configparserre ConfigParserrrsectionsr6matchgroupr) rrcfgautover_sectionconfigrr=r<archive_commit_keysections rget_setupcfg_versionrsJ C$O  & & (F KKjjF+GSbflfufufwSwvzz/*:g:NzO~EHN()RR??$   0 1XX&7@FFqIN% S(7R` aar"ceZdZdZ ddZedZedZedZedZ dZ dd Z d Z d Z d Zdd ZdZdZdZddZy)r*a A simple approach to Python package versioning that supports PyPI releases and additional information when working with version control. When obtaining a package from PyPI, the version returned is a string-formatted rendering of the supplied release tuple. For instance, release (1,0) tagged as ``v1.0`` in the version control system will return ``1.0`` for ``str(__version__)``. Any number of items can be supplied in the release tuple, with either two or three numeric versioning levels typical. During development, a command like ``git describe`` will be used to compute the number of commits since the last version tag, the short commit hash, and whether the commit is dirty (has changes not yet committed). Version tags must start with a lowercase 'v' and have a period in them, e.g. v2.0, v0.9.8 or v0.1. Development versions are supported by setting the dev argument to an appropriate dev version number. The corresponding tag can be PEP440 compliant (using .devX) of the form v0.1.dev3, v1.9.0.dev2 etc but it doesn't have to be as the dot may be omitted i.e v0.1dev3, v1.9.0dev2 etc. Also note that when version control system (VCS) information is used, the comparison operators take into account the number of commits since the last version tag. This approach is often useful in practice to decide which version is newer for a single developer, but will not necessarily be reliable when comparing against a different fork or branch in a distributed VCS. For git, if you want version control information available even in an exported archive (e.g. a .zip file from GitHub), you can set the following line in the .gitattributes file of your project:: __init__.py export-subst Nc||_||_||_|dvrdn||_||_d|_d|_||_||_y)a :release: Release tuple (corresponding to the current VCS tag) :commit Short SHA. Set to '$Format:%h$' for git archive support. :fpath: Set to ``__file__`` to access version control information :reponame: Used to verify VCS repository name. :dev: Development version number. None if not a development version. :commit_count Commits since last release. Set for dev releases. Nz $Format:%h$NF) r2r3r5r7r8r9r:r=r')r?r&r2r@r=r'r(s rrAzOldDeprecatedVersion.__init__CsP & '%)>>tF )    r"c6|jjSrGrHrDs rr&zOldDeprecatedVersion.releaseXrIr"c6|jjSrKrLrDs rr@zOldDeprecatedVersion.commit]rMr"c6|jjSrOrPrDs rr(z!OldDeprecatedVersion.commit_countbrQr"c6|jjSrSrTrDs rrUzOldDeprecatedVersion.dirtygrVr"c|j|S|j|_|js|j|_|SdD]} |j ||S|S#t $rY&wxYwrXrZr]s rrCzOldDeprecatedVersion.fetchmr_r`c |jqt|ddgtjj |j d|jzdzd|jzdzg}t fd|Ds|St|dd d d d gtjj |j |jy#t$r)}|jd dk(r td|cYd}~Sd}~wwxYw)Nrbrcrdrerfrgc3&K|]}|v ywr r))rrirs rrz1OldDeprecatedVersion.git_fetch..s= 11; rkrlrmrnzv*.*rorprqrr) r=r!rrsrtr2rurrrw)r?r^r{ers @rr[zOldDeprecatedVersion.git_fetchs }}(!#x!6%'WW__TZZ%@B #dmm 3f <!$dmm 3c 9 ; = ==Kc:xFIV!#!<>F f%  vvayNN QRRK  s$AC93C>9C>c|ddjd}d|dvrN|djd}t|d|_|d|d<|djdr |ddd|d<t d|djdD|_t|d|_t|d dd|_|dd k(|_ |S) rrpNrr'rrrc32K|]}t|ywr rrs rrz8OldDeprecatedVersion._update_from_vcs..sD0C"c"g0CrrrU) rrr'endswithrr9r8r r7r:)r?rr dev_splits rrwz%OldDeprecatedVersion._update_from_vcssqr   % E!H au-I9Q<(DH |E!HQx  %$Q<,aDas0CDD  q]58AB<( Ry')  r"c|jydjd|jD}|jd||jfzn|}|jd|jvrn|jdk(r|j s|S|j rdnd}d j ||jr |jnd |j|S) rrrc32K|]}t|ywr rrs rrz/OldDeprecatedVersion.__str__..rrz%s.dev%dr1rrrz {}-{}-g{}{}x)r&rr'r3r(rUrr@)r?r& dirty_statuss rrzOldDeprecatedVersion.__str__s << ((:T\\::6:hh6J*22PW  ! ! -YdF[F[5[ 1$TZZN#'::x2 ##G$BSBST->->Y\ $ \; ;r"ct|Sr rrDs rrzOldDeprecatedVersion.__repr__rr"cdjd|jD|jdkDs |jr|zSdzS)zv Abbreviated string representation, optionally declaring whether it is a development version. rc32K|]}t|ywr rrs rrz.OldDeprecatedVersion.abbrev..rrrr)rr&r(rU)r? dev_suffixs rrzOldDeprecatedVersion.abbrevsK xx7$,,77,,q0DJJZH HDFH Hr"c|js |jry|j|j|jf|j|j|jfk(S)a[ Two versions are considered equivalent if and only if they are from the same release, with the same commit count, and are not dirty. Any dirty version is considered different from any other version, since it could potentially have any arbitrary changes even for the same release and commit count. F)rUr&r(r'r?others r__eq__zOldDeprecatedVersion.__eq__sO ::Ut00$((;MM5#5#5uyyAB Cr"c||j|jk(rs|j|jk(r|j|jkDSd|j|jfvr|jduS|j|jkDS|j|jf|j|jfkDSr )r&r'r(r s r__gt__zOldDeprecatedVersion.__gt__s <<5== (xx599$((5+=+===$((EII..xx4''xx%))++LL$"3"34 uGYGY7ZZ Zr"c||k(ry||kD S)NFr)r s r__lt__zOldDeprecatedVersion.__lt__s ;u % %r"c|r|t|k7r td|jr td|j|jk7r td|j dk7r td|j dvr tdy) rrrrrrrrN)r rrUr&r5r(r3rs rrzOldDeprecatedVersion.verifys nD 9UV V ::AB B <<400 0RS S   q OP P  (= =QR R >r")NNNNNr)rY)rr )rrrrrArr&r@r(rUrCr[rwrrrr rrrr)r"rr*r*s"H9=78*%%$$**## .&2$;2H C [&Sr"r*r )NN) r __author__rrrr!r$rrr*r)r"rrsG$  &\&\&@ D06btiSiSr"