파이썬 패키지에 버전을 포함시키는 표준 방법?

다음을 수행 할 수있는 방식으로 버전 문자열을 파이썬 패키지와 연결하는 표준 방법이 있습니까?

import foo
print foo.version

작은 / 주요 문자열이 setup.py이미 지정되어 있으므로 추가 하드 코딩없이 해당 데이터를 검색 할 수있는 방법이 있다고 생각합니다 . 내가 발견 한 대체 솔루션은 것이 었 import __version__내에서 foo/__init__.py다음 한 __version__.py에 의해 생성 setup.py.

귀하의 질문에 대한 직접적인 대답은 아니지만 __version__, 이름을 고려해야합니다 version.

이것은 거의 준 표준입니다. 표준 라이브러리의 많은 모듈이을 __version__사용하며 많은 타사 모듈 에서도 사용 되므로 준 표준입니다.

일반적으로 __version__문자열이지만 때로는 float 또는 tuple이기도합니다.

편집 : S.Lott (감사합니다!)가 언급했듯이 PEP 8 은 다음과 같이 명시 적으로 말합니다.

모듈 레벨 던더 이름

같은 (이 선도하고 두 후행 밑줄 즉, 이름) 모듈 수준 "dunders"는 __all__, __author__, __version__등 모듈의 문서화 문자열 뒤에 있지만에서 제외 import 문 앞에 배치해야 __future__가져옵니다.

또한 버전 번호가 PEP 440 ( 이 표준의 이전 버전 인 PEP 386)에 설명 된 형식을 준수하는지 확인해야합니다 .

_version.py버전 정보를 저장 하기 위해 단일 파일을 "한 번 정식 위치"로 사용합니다.

1. __version__속성을 제공 합니다.

2. 표준 메타 데이터 버전을 제공합니다. 따라서 pkg_resources패키지 메타 데이터 (EGG-INFO 및 / 또는 PKG-INFO, PEP 0345)를 구문 분석하는 도구 또는 기타 도구에 의해 감지됩니다 .

3. 패키지를 만들 때 패키지 또는 다른 것을 가져 오지 않으므로 일부 상황에서 문제가 발생할 수 있습니다. (이로 인해 발생할 수있는 문제에 대해서는 아래 주석을 참조하십시오.)

4. 버전 번호가 기록 된 장소는 하나뿐이므로 버전 번호가 변경 될 때 버전 번호를 변경할 장소는 하나 뿐이며 버전이 일치하지 않을 가능성이 적습니다.

작동 방식은 다음과 같습니다. 버전 번호를 저장하는 "한 곳의 정식 장소"는 Python 패키지에있는 "_version.py"라는 .py 파일입니다 (예 :) myniftyapp/_version.py. 이 파일은 Python 모듈이지만 setup.py에서 가져 오지 않습니다! (이것은 기능 3을 물리치게됩니다.) 대신 setup.py는이 파일의 내용이 매우 단순하다는 것을 알고 있습니다.

__version__ = "3.6.5"

따라서 setup.py는 파일을 열고 다음과 같은 코드로 파싱합니다.

import re
VERSIONFILE="myniftyapp/_version.py"
verstrline = open(VERSIONFILE, "rt").read()
VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]"
mo = re.search(VSRE, verstrline, re.M)
if mo:
    verstr = mo.group(1)
else:
    raise RuntimeError("Unable to find version string in %s." % (VERSIONFILE,))

그런 다음 setup.py는 해당 문자열을 "version"인수의 값으로로 전달 setup()하여 기능 2를 만족시킵니다.

기능 1을 충족시키기 위해 패키지를 설정 시간이 아닌 런타임에 _version 파일을 다음 myniftyapp/__init__.py과 같이 가져올 수 있습니다 .

from _version import __version__

다음은 몇 년 동안 사용해온 이 기술의 예입니다 .

이 예제의 코드는 조금 더 복잡하지만이 주석에 쓴 간단한 예제는 완전한 구현이어야합니다.

다음은 버전을 가져 오는 예제 코드입니다 .

이 방법에 문제가 있으면 알려주십시오.

2017-05 재 작성

파이썬 코드를 작성하고 다양한 패키지를 관리한지 10 년이 지난 후에 저는 DIY가 최선의 방법이 아니라는 결론에 도달했습니다.

pbr패키지의 버전 관리를 위해 패키지를 사용하기 시작했습니다 . git을 SCM으로 사용하는 경우 마술처럼 워크 플로에 적합하여 몇 주 동안의 작업 시간을 절약 할 수 있습니다 (문제가 얼마나 복잡 할 수 있는지에 놀랄 것입니다).

현재 pbr은 11 번째로 가장 많이 사용되는 파이썬 패키지로 순위가 매겨졌으며이 수준에 도달 하는 데는 더티 트릭이 포함되지 않았습니다.

pbr 패키지 유지 관리 부담을 더 많이 할 수 있으며 버전 관리에만 국한되지는 않지만 모든 이점을 채택하도록 강요하지는 않습니다.

따라서 한 번의 커밋에서 pbr을 채택하는 방법에 대한 아이디어를 얻으려면 pbr에 swiching 포장을하십시오.

아마도 버전이 저장소에 전혀 저장되지 않았 음을 알 수 있습니다. PBR은 Git 브랜치 및 태그에서이를 감지합니다.

pbr은 응용 프로그램을 패키지하거나 설치할 때 버전을 "컴파일"하고 캐시하므로 git 저장소가 없을 때 발생하는 상황에 대해 걱정할 필요가 없으므로 git에 런타임 종속성이 없습니다.

오래된 솔루션

지금까지 내가 본 최고의 솔루션은 다음과 같은 이유도 설명합니다.

내부 yourpackage/version.py:

# Store the version here so:
# 1) we don't load dependencies by storing it in __init__.py
# 2) we can import it in setup.py for the same reason
# 3) we can import it into your module module
__version__ = '0.12'

내부 yourpackage/__init__.py:

from .version import __version__

내부 setup.py:

exec(open('yourpackage/version.py').read())
setup(
    ...
    version=__version__,
    ...

더 나은 것으로 보이는 다른 접근법을 알고 있다면 알려주십시오.

지연된 PEP 396 (모듈 버전 번호) 에 따라 제안 된 방법이 있습니다. 여기에는 이론적으로 모듈이 따라야 할 (선택적으로 선택적인) 표준이 설명되어 있습니다. 스 니펫은 다음과 같습니다.

3) 모듈 (또는 패키지)에 버전 번호가 포함 된 경우, __version__속성 에서 버전을 사용할 수 있어야 합니다.

4) 네임 스페이스 패키지 내에 존재하는 모듈의 경우, 모듈은 __version__속성을 포함해야 한다. 네임 스페이스 패키지 자체에는 자체 __version__속성이 포함되어서는 안된다 (SHOULD NOT) .

5) __version__속성 값은 문자열이어야한다.

이것이 너무 늦었지만 이전 답변에 대한 약간 더 간단한 대안이 있습니다.

__version_info__ = ('1', '2', '3')
__version__ = '.'.join(__version_info__)

(그리고 버전 번호의 자동 증가 부분을 문자열을 사용하여 변환하는 것은 매우 간단합니다 str().)

물론 내가 본 것에서 사람들은을 사용할 때 이전에 언급 한 버전과 같은 것을 사용하는 경향이 __version_info__있으며, 따라서 튜플의 정수로 저장합니다. 그러나 호기심이나 자동 증가 (그리고 심지어는, 어떤 경우에도 버전 번호의 일부에 대한 뺄셈과 같은 수학적 연산을 수행 할 상황이 의심 스럽기 때문에 그렇게하는 요점을 알지 못합니다. int()과 str()) 매우 쉽게 사용할 수 있습니다. (다른 한편으로, 다른 사람의 코드가 문자열 튜플이 아닌 숫자 튜플을 기대하여 실패 할 가능성이 있습니다.)

이것은 물론 내 자신의 견해이며, 숫자 튜플 사용에 대한 다른 사람들의 의견을 기쁘게 생각합니다.

shezi가 상기 한 것처럼, 숫자 문자열에 대한 (어휘) 비교는 직접적인 수치 비교와 반드시 같은 결과를 가질 필요는 없습니다. 이를 위해서는 선행 제로가 필요합니다. 따라서 결국 __version_info__정수 값의 튜플로 저장 하거나 호출하면 더 효율적인 버전 비교가 가능합니다.

이 솔루션 중 다수는 git버전 태그를 무시 하므로 여전히 여러 위치에서 버전을 추적해야합니다 (나쁜). 나는 다음 목표로 이것에 접근했다.

• gitrepo 의 태그에서 모든 Python 버전 참조를 파생하십시오.
• 자동화 git tag/ push과 setup.py upload어떤 입력을지지 않습니다 하나의 명령으로 단계.

작동 방식 :

1. A로부터 make release명령의 자식의 repo의 마지막 태그 버전을 찾아 증가합니다. 태그가로 푸시됩니다 origin.

2. 이 Makefile버전은 버전을 src/_version.py읽고 setup.py릴리스에 포함 할 버전을 저장합니다 . 소스 컨트롤을 확인하지 마십시오 _version.py!

3. setup.py명령은에서 새 버전 문자열을 읽습니다 package.__version__.

세부:

메이크 파일

# remove optional 'v' and trailing hash "v1.0-N-HASH" -> "v1.0-N"
git_describe_ver = $(shell git describe --tags | sed -E -e 's/^v//' -e 's/(.*)-.*/\1/')
git_tag_ver      = $(shell git describe --abbrev=0)
next_patch_ver = $(shell python versionbump.py --patch $(call git_tag_ver))
next_minor_ver = $(shell python versionbump.py --minor $(call git_tag_ver))
next_major_ver = $(shell python versionbump.py --major $(call git_tag_ver))

.PHONY: ${MODULE}/_version.py
${MODULE}/_version.py:
    echo '__version__ = "$(call git_describe_ver)"' > $@

.PHONY: release
release: test lint mypy
    git tag -a $(call next_patch_ver)
    $(MAKE) ${MODULE}/_version.py
    python setup.py check sdist upload # (legacy "upload" method)
    # twine upload dist/*  (preferred method)
    git push origin master --tags

release목표는 항상 3 버전 숫자를 증가,하지만 당신은 사용할 수 있습니다 next_minor_ver또는 next_major_ver다른 숫자를 증가 할 수 있습니다. 명령은 versionbump.py리포지토리의 루트에 체크인 된 스크립트 에 의존합니다.

versionbump.py

"""An auto-increment tool for version strings."""

import sys
import unittest

import click
from click.testing import CliRunner  # type: ignore

__version__ = '0.1'

MIN_DIGITS = 2
MAX_DIGITS = 3


@click.command()
@click.argument('version')
@click.option('--major', 'bump_idx', flag_value=0, help='Increment major number.')
@click.option('--minor', 'bump_idx', flag_value=1, help='Increment minor number.')
@click.option('--patch', 'bump_idx', flag_value=2, default=True, help='Increment patch number.')
def cli(version: str, bump_idx: int) -> None:
    """Bumps a MAJOR.MINOR.PATCH version string at the specified index location or 'patch' digit. An
    optional 'v' prefix is allowed and will be included in the output if found."""
    prefix = version[0] if version[0].isalpha() else ''
    digits = version.lower().lstrip('v').split('.')

    if len(digits) > MAX_DIGITS:
        click.secho('ERROR: Too many digits', fg='red', err=True)
        sys.exit(1)

    digits = (digits + ['0'] * MAX_DIGITS)[:MAX_DIGITS]  # Extend total digits to max.
    digits[bump_idx] = str(int(digits[bump_idx]) + 1)  # Increment the desired digit.

    # Zero rightmost digits after bump position.
    for i in range(bump_idx + 1, MAX_DIGITS):
        digits[i] = '0'
    digits = digits[:max(MIN_DIGITS, bump_idx + 1)]  # Trim rightmost digits.
    click.echo(prefix + '.'.join(digits), nl=False)


if __name__ == '__main__':
    cli()  # pylint: disable=no-value-for-parameter

이것은에서 버전 번호를 처리하고 증가시키는 방법을 많이 들어 올립니다 git.

__init__.py

my_module/_version.py파일로 가져옵니다 my_module/__init__.py. 모듈과 함께 배포하려는 정적 설치 구성을 여기에 넣으십시오.

from ._version import __version__
__author__ = ''
__email__ = ''

setup.py

마지막 단계는 my_module모듈 에서 버전 정보를 읽는 것 입니다.

from setuptools import setup, find_packages

pkg_vars  = {}

with open("{MODULE}/_version.py") as fp:
    exec(fp.read(), pkg_vars)

setup(
    version=pkg_vars['__version__'],
    ...
    ...
)

물론이 모든 기능이 작동하려면 리포지토리에 버전 태그가 하나 이상 있어야 시작할 수 있습니다.

git tag -a v0.0.1

패키지 디렉토리에 JSON 파일을 사용합니다. 이것은 Zooko의 요구 사항에 맞습니다.

내부 pkg_dir/pkg_info.json:

{"version": "0.1.0"}

내부 setup.py:

from distutils.core import setup
import json

with open('pkg_dir/pkg_info.json') as fp:
    _info = json.load(fp)

setup(
    version=_info['version'],
    ...
    )

내부 pkg_dir/__init__.py:

import json
from os.path import dirname

with open(dirname(__file__) + '/pkg_info.json') as fp:
    _info = json.load(fp)

__version__ = _info['version']

pkg_info.json저자와 같은 다른 정보도 넣었습니다 . 메타 데이터 관리를 자동화 할 수 있기 때문에 JSON을 사용하고 싶습니다.

또한 주목할만한 가치 __version__는 준 표준입니다. 파이썬 __version_info__에서는 튜플입니다. 간단한 경우에는 다음과 같이 할 수 있습니다.

__version__ = '1.2.3'
__version_info__ = tuple([ int(num) for num in __version__.split('.')])

... __version__파일 에서 문자열 등을 가져올 수 있습니다 .

파이썬 패키지에 버전 문자열을 포함시키는 표준 방법은없는 것 같습니다. 내가 본 대부분의 패키지는 솔루션의 일부 변형, 즉 eitner를 사용합니다.

1. 버전을 임베드하고 패키지에서 가져온 버전 정보 만 포함 하는 모듈 (예 :) setup.py을 setup.py생성 version.py하십시오.

2. 역 : 버전 패키지 자체 정보, 수입 넣어 것을 의 버전을 설정을 setup.py

화살표 는 흥미로운 방식으로 처리합니다.

이제 ( 2e5031b 부터 )

에서 arrow/__init__.py:

__version__ = 'x.y.z'

에서 setup.py:

from arrow import __version__

setup(
    name='arrow',
    version=__version__,
    # [...]
)

전에

에서 arrow/__init__.py:

__version__ = 'x.y.z'
VERSION = __version__

에서 setup.py:

def grep(attrname):
    pattern = r"{0}\W*=\W*'([^']+)'".format(attrname)
    strval, = re.findall(pattern, file_text)
    return strval

file_text = read(fpath('arrow/__init__.py'))

setup(
    name='arrow',
    version=grep('__version__'),
    # [...]
)

나는 또 다른 스타일을 보았다 :

>>> django.VERSION
(1, 1, 0, 'final', 0)

사용 setuptools하여pbr

버전을 관리하는 표준 방법은 없지만 패키지를 관리하는 표준 방법은 setuptools입니다.

버전 관리를 위해 전체적으로 찾은 최고의 솔루션 setuptools은 pbr확장 프로그램 과 함께 사용 하는 것 입니다. 이것이 현재 버전 관리의 표준 방법입니다.

전체 패키징을 위해 프로젝트를 설정하는 것은 간단한 프로젝트에는 무리가 될 수 있지만 버전을 관리해야하는 경우 모든 것을 설정하기에 적합한 수준 일 수 있습니다. 그렇게하면 PyPi 에서 패키지를 릴리스 할 수 있으므로 모든 사람이 Pip과 함께 패키지 를 다운로드하여 사용할 수 있습니다.

PBR은 대부분의 메타 데이터를 setup.py도구에서 setup.cfg파일로 이동 한 다음 버전을 포함 할 수있는 대부분의 메타 데이터의 소스로 사용됩니다. 이를 통해 메타 데이터를 pyinstaller필요한 경우 ( 필요한 경우이 정보 가 필요할 수 있음)를 사용하여 실행 파일로 패키지 할 수 있으며 메타 데이터를 다른 패키지 관리 / 설정 스크립트와 분리합니다. 버전 문자열을 setup.cfg수동으로 직접 업데이트 할 수 있으며 *.egg-info패키지 릴리스를 빌드 할 때 폴더 로 가져옵니다 . 그런 다음 스크립트는 다양한 방법을 사용하여 메타 데이터에서 버전에 액세스 할 수 있습니다 (이 프로세스는 아래 섹션에 요약되어 있음).

VCS / SCM에 Git을 사용하는 경우이 설정은 Git에서 많은 메타 데이터를 가져 와서 버전, 작성자, 변경 로그, 특히 버전의 경우 repo의 git 태그를 기반으로 현재 커밋의 버전 문자열을 만듭니다.

• PyPA-SetupTools로 파이썬 패키지 패키징-튜토리얼
• PBR 최신 빌드 사용 문서 - 메타 데이터 로 8 행 setup.py및 setup.cfg파일 을 설정하는 방법

PBR은 git repo에서 직접 버전, 작성자, 변경 로그 및 기타 정보를 가져 오기 때문에 setup.cfg패키지에 대한 배포가 생성 될 때마다 메타 데이터 중 일부가 생략되고 자동 생성 될 수 있습니다 ( setup.py)

실시간 현재 버전

setuptools다음을 사용하여 최신 정보를 실시간으로 가져옵니다 setup.py.

python setup.py --version

이것은 setup.cfg최신 커밋과 repo에 존재하는 태그를 기반으로 파일 또는 git repo 에서 최신 버전을 가져옵니다 . 이 명령은 배포판의 버전을 업데이트하지 않습니다.

버전 업데이트

setup.py예를 들어을 사용하여 배포를 생성하면 py setup.py sdist모든 현재 정보가 추출되어 배포에 저장됩니다. 이것은 기본적으로 setup.py --version명령을 실행 한 다음 해당 버전 정보를 package.egg-info배포 메타 데이터를 저장하는 파일 세트의 폴더에 저장합니다.

버전 메타 데이터를 업데이트하는 프로세스에 대한 참고 사항 :

pbr을 사용하여 git에서 버전 데이터를 가져 오지 않는다면 setup.cfg를 새 버전 정보로 직접 업데이트하십시오 (쉽지만 릴리스 프로세스의 표준 부분인지 확인하십시오).

git을 사용하고 소스 또는 바이너리 배포판을 만들 필요가 없다면 ( 명령 python setup.py sdist중 하나를 사용하여 python setup.py bdist_xxx) git repo 정보를 <mypackage>.egg-info메타 데이터 폴더 로 업데이트하는 가장 간단한 방법 은 python setup.py install명령을 실행하는 것 입니다. 이것은 git repo에서 메타 데이터 가져 오기와 관련된 모든 PBR 기능을 실행하고 로컬 .egg-info폴더를 업데이트하고 , 정의한 진입 점에 대한 스크립트 실행 파일을 설치하고,이 명령을 실행할 때 출력에서 ​​볼 수있는 다른 기능을 실행합니다.

이 .egg-info폴더는 일반적으로 소스에서 생성 될 수 있기 때문에 표준 Python .gitignore파일 (예 : Gitignore.IO ) 로 git repo 자체에 저장되지 않습니다 . 제외 된 경우, 릴리스 전에 메타 데이터를 로컬로 업데이트하기위한 표준 "릴리스 프로세스"가 있는지 확인하고 PyPi.org에 업로드하거나 배포하는 패키지에는이 데이터가 포함되어 있어야 올바른 버전을 사용할 수 있습니다. 당신이 원하는 경우 힘내 (예 : 추가, 당신이 무시되는 특정 파일을 제외 할 수 있습니다이 정보를 포함 REPO !*.egg-info/PKG_INFO에 .gitignore)

스크립트에서 버전에 액세스

패키지 자체의 Python 스크립트 내 현재 빌드에서 메타 데이터에 액세스 할 수 있습니다. 예를 들어 버전의 경우 지금까지 내가 찾은 몇 가지 방법이 있습니다.

## This one is a new built-in as of Python 3.8.0 should become the standard
from importlib-metadata import version

v0 = version("mypackage")
print('v0 {}'.format(v0))

## I don't like this one because the version method is hidden
import pkg_resources  # part of setuptools

v1 = pkg_resources.require("mypackage")[0].version
print('v1 {}'.format(v1))

# Probably best for pre v3.8.0 - the output without .version is just a longer string with
# both the package name, a space, and the version string
import pkg_resources  # part of setuptools

v2 = pkg_resources.get_distribution('mypackage').version
print('v2 {}'.format(v2))

## This one seems to be slower, and with pyinstaller makes the exe a lot bigger
from pbr.version import VersionInfo

v3 = VersionInfo('mypackage').release_string()
print('v3 {}'.format(v3))

__init__.py다른 답변과 마찬가지로 패키지 중 하나를 패키지에 직접 넣어서 버전 정보를 다음과 같이 추출 할 수 있습니다 .

__all__ = (
    '__version__',
    'my_package_name'
)

import pkg_resources  # part of setuptools

__version__ = pkg_resources.get_distribution("mypackage").version

가장 단순하고 안정적인 솔루션을 찾기 위해 몇 시간 동안 노력한 후에 다음과 같은 부분이 있습니다.

"/ mypackage"패키지 폴더 안에 version.py 파일을 생성하십시오 :

# Store the version here so:
# 1) we don't load dependencies by storing it in __init__.py
# 2) we can import it in setup.py for the same reason
# 3) we can import it into your module module
__version__ = '1.2.7'

setup.py에서 :

exec(open('mypackage/version.py').read())
setup(
    name='mypackage',
    version=__version__,

메인 폴더 init .py에서 :

from .version import __version__

exec()모듈을 가져올 수 있습니다 전에 setup.py를 실행하기 때문에 기능은 모든 수입의 스크립트 외부를 실행합니다. 한 위치에서 한 파일의 버전 번호 만 관리하면되지만 불행히도 setup.py에는 없습니다. (그것은 단점이지만 수입 버그가없는 것이 단점입니다)

이 질문이 처음 제기 된 이후 로 균일 한 버전 관리와 컨벤션 지원을위한 많은 작업이 완료되었습니다 . 입맛 에 맞는 옵션은 이제 Python Packaging 사용자 안내서에 자세히 설명 되어 있습니다. 또한 PEP 440 당 Python 에서는 버전 번호 체계가 상대적으로 엄격 하므로 패키지가 치즈 샵에 출시 될 경우 제정신을 유지하는 것이 중요 합니다 .

버전 관리 옵션의 단축 된 분류는 다음과 같습니다.

1. setup.py( setuptools ) 에서 파일을 읽고 버전을 얻으십시오.
2. bump2version , changes 또는 zest.releaser__init__.py 와 같은 외부 빌드 도구를 사용하여 소스 제어뿐 아니라 소스 제어도 업데이트 하십시오 .
3. __version__특정 모듈에서 값을 전역 변수로 설정하십시오 .
4. setup.py 및 읽을 코드 모두에 대해 간단한 VERSION 텍스트 파일에 값을 배치하십시오.
5. setup.py릴리스 를 통해 값을 설정하고 importlib.metadata 를 사용 하여 런타임시 선택하십시오. (경고 3.8 이전 및 3.8 이후 버전이 있습니다.)
6. 로 값을 설정하고 __version__에서 sample/__init__.py샘플을 가져옵니다 setup.py.
7. setuptools_scm 을 사용 하여 소스 제어에서 코드화가 아닌 정식 참조가되도록 버전 관리를 추출 하십시오 .

주 (7)이 될 수 있음을 가장 현대적인 접근 방식 (빌드 메타 데이터는 자동으로 게시, 코드의 독립적이다). 또한 참고 설치 패키지 릴리스를 사용하면 간단한이 있다는 것을 python3 setup.py --version직접 버전을보고합니다.

가치있는 것을 위해 NumPy distutils를 사용 하는 경우 수정 번호를 변수 안에 포함 numpy.distutils.misc_util.Configuration시키는 make_svn_version_py()메소드가 있습니다.package.__svn_version__version

1. version.py파일에 __version__ = <VERSION>param이 있는 파일 만 사용하십시오 . 에서 setup.py파일 가져 __version__PARAM을하고에 값을 넣어 setup.py같은 파일 : version=__version__
2. 또 다른 방법은 CURRENT_VERSION이 하드 코딩 된 setup.py파일 만 사용하는 것 version=<CURRENT_VERSION>입니다.

새 태그를 만들 때마다 (새 패키지 버전을 릴리스 할 준비가 될 때마다) 파일의 버전을 수동으로 변경하고 싶지 않기 때문에 다음을 사용할 수 있습니다.

나는 bumpversion을 강력히 추천 한다 패키지를 . 몇 년 동안 버전을 사용하여 사용했습니다.

에 추가 version=<VERSION>하여 시작setup.py파일이 없으면 먼저 파일 .

버전이 충돌 할 때마다 다음과 같은 짧은 스크립트를 사용해야합니다.

bumpversion (patch|minor|major) - choose only one option
git push
git push --tags

그런 다음 리포지토리 당 파일 하나를 추가하십시오. .bumpversion.cfg:

[bumpversion]
current_version = <CURRENT_TAG>
commit = True
tag = True
tag_name = {new_version}
[bumpversion:file:<RELATIVE_PATH_TO_SETUP_FILE>]

노트 :

• 다른 게시물에서 제안한 것처럼 파일에서 __version__매개 변수 를 사용 version.py하고 다음과 같이 bumpversion 파일을 업데이트 할 수 있습니다. [bumpversion:file:<RELATIVE_PATH_TO_VERSION_FILE>]
• 당신 은 git commit 또는git reset , 그렇지 않으면 당신은 더러운 환매 특약 오류가 발생합니다, 당신의 repo에있는 모든.
• 가상 환경에 충돌 버전 패키지가 포함되어 있는지 확인하십시오.

CVS (또는 RCS)를 사용하고 빠른 솔루션을 원하는 경우 다음을 사용할 수 있습니다.

__version__ = "$Revision: 1.1 $"[11:-2]
__version_info__ = tuple([int(s) for s in __version__.split(".")])

(물론 개정 번호는 CVS로 대체됩니다.)

이렇게하면 인쇄하기 쉬운 버전과 가져 오는 모듈에 최소한 예상되는 버전이 있는지 확인할 수있는 버전 정보가 제공됩니다.

import my_module
assert my_module.__version_info__ >= (1, 1)