Standardmethode zum Einbetten der Version in das Python-Paket?

Nicht direkt eine Antwort auf deine Frage, aber man sollte überlegen die Namensgebung __version__nicht version.

Dies ist fast ein quasi-standard. Viele Module in der standard-Bibliothek verwenden __version__und dies ist auch in viele von 3rd-party-Module, so ist es der quasi-standard.

Normalerweise __version__ ist ein string, aber manchmal ist es auch ein float oder Tupel.

Edit: wie erwähnt von S. Lott (Danke!), PEP 8 sagt es ausdrücklich:

Version Buchhaltung

Wenn Sie Subversion, CVS, RCS oder dreck in der Quell-Datei
tun Sie es wie folgt.

    __version__ = "$Revision: 63990 $"
    # $Source$

Diese Zeilen sollten enthalten sein, nachdem das Modul den docstring, bevor
jeder andere code, getrennt durch eine Leerzeile oben und unten.

Sollten Sie auch sicherstellen, dass die Versionsnummer entspricht dem beschriebenen format in PEP 440 (PEP 386 einer früheren version dieses Standards).

InformationsquelleAutor der Antwort oefe

Umgeschrieben 2017-05

Nach mehr als zehn Jahren ein schreiben von Python-code und die Verwaltung verschiedener Pakete, die ich kam zu dem Schluss, dass DIY ist vielleicht nicht der beste Ansatz.

Begann ich mit pbr - Paket für den Umgang mit der Versionsverwaltung in meiner Pakete. Wenn Sie der Verwendung von git als die SCM, dieses passen in Ihren workflow wie Magie, sparen Sie Ihre Wochen der Arbeit (Sie werden überrascht sein darüber, wie Komplex das Thema werden kann).

Heute pbr ist auf Platz #11 am meisten verwendeten python-Paket und erreichen dieses Niveau nicht enthalten keine schmutzigen tricks: war nur eines: die Festsetzung einer gemeinsamen Verpackung problem in einer sehr einfachen Weise.

pbr können mehr tun, das Paket Bürde der Wartung, ist nicht beschränkt auf Versionierung, aber es zwingt Sie nicht, sich zu verabschieden, alle Ihre Vorteile.

So, um Ihnen eine Idee über, wie es aussieht verabschieden, pbr in einem commit haben Sie einen Blick swiching Verpackung zu pbr

Wahrscheinlich würden Sie beobachtet, dass die version nicht gespeichert, überhaupt in das repository. PBR erkennt es aus dem Git branches und tags.

Muss sich keine sorgen machen über das, was passiert, wenn Sie nicht über ein git-repository, da pbr bedeutet "kompilieren" und cache die version, wenn Sie ein Paket oder installieren Sie die Anwendungen, so gibt es keine runtime-Abhängigkeit von git.

Alten Lösung

Hier ist die beste Lösung, die ich bisher gesehen habe, und es erklärt auch, warum:

Innen 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'

Innen yourpackage/__init__.py:

from .version import __version__

Innen setup.py:

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

Wenn Sie wissen, einen anderen Ansatz, der besser zu sein scheint, lassen Sie es mich wissen.

InformationsquelleAutor der Antwort sorin

Obwohl dies wahrscheinlich viel zu spät, es ist eine etwas einfachere alternative zu der vorherigen Antwort:

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

(Und es wäre ziemlich einfach zu konvertieren von auto-increment-Portionen-version zahlen in eine Zeichenfolge mit str().)

Natürlich, von dem, was ich gesehen habe, neigen die Menschen dazu, etwas zu verwenden, wie die bereits erwähnte version bei der Verwendung von __version_info__und als solche speichern Sie es als ein Tupel von int-Werten; jedoch, ich verstehe nicht ganz den Punkt sehen dabei, wie ich bezweifle, dass es Situationen gibt, wo würden Sie führen mathematische Operationen wie addition und Subtraktion auf Teile von Versionsnummern für andere Zwecke als die Neugier oder die auto-Inkrementierung (und selbst dann int() und str() verwendet werden können, relativ leicht). (Auf der anderen Seite gibt es die Möglichkeit, dass jemand anderes den code erwarten ein numerisches Tupel statt eines Strings Tupel und somit keine.)

Dies ist natürlich meine eigene Meinung, und ich würde gerne, wie andere " - Eingang zur Verwendung eines numerischen Tupel.

Als shezi erinnerte mich, (lexikalischen) Vergleiche der Anzahl Saiten müssen nicht unbedingt zum gleichen Ergebnis wie die direkte numerische Vergleiche; führende Nullen erforderlich sein würde dafür sorgen. Also am Ende, speichern __version_info__ (oder was auch immer es genannt werden würde) als ein Tupel von integer-Werten wäre für effizientere version Vergleiche.

InformationsquelleAutor der Antwort JAB

Scheint es nicht zu sein, einen standard zum einbetten einer version-string in ein python-Paket. Die meisten Pakete, die ich gesehen habe verwenden eine Variante der Lösung, D. H. eitner

1. Einbetten der version in setup.py und haben setup.py generieren eines Moduls (z.B. version.py) nur mit version-info, importiert, die von dem Paket, oder

2. Umgekehrt: die version info in Ihrem Paket selbst, und importieren dass um die version in setup.py

InformationsquelleAutor der Antwort dF.

Viele dieser Lösungen hier ignorieren git version-tags, die immer noch bedeutet, dass Sie haben, um track-version in mehreren Orten (bad). Ich näherte mich dies mit den folgenden Zielen:

• Leiten Sie alle python-version Referenzen von einem tag in der git repo
• Automatisieren git tag/push und setup.py upload Schritte mit einem einzigen Befehl, der nimmt keine Eingaben.

Wie es funktioniert:

1. Vom make release Befehl, die letzten tagged version im git-repo gefunden wird und erhöht wird. Der tag ist zurückgedrängt origin.

2. Den Makefile speichert die version in src/_version.py wo es gelesen wird von setup.py und auch im release. Nicht überprüfen _version.py in die Quellcodeverwaltung!

3. setup.py Befehl liest die neue version-string aus package.__version__.

Details:

Makefile

# 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

Den release Ziel immer Schritten die 3. version stellige, aber Sie können die next_minor_ver oder next_major_ver erhöhen die anderen Ziffern. Die Befehle stützen sich auf den versionbump.py script, der überprüft wird, in die Wurzel des repo -

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

Dies tut die schwerarbeit, wie die Verarbeitung und erhöht die Versionsnummer von git.

__init__.py

Den my_module/_version.py - Datei importiert wird, in my_module/__init__.py. Stellen Sie keine statische install-config hier, dass Sie wollen zusammen mit Ihrem Modul.

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

setup.py

Den letzten Schritt Lesen Sie die versions-info aus der my_module Modul.

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__'],
    ...
    ...
)

Natürlich, für alle diese arbeiten musst du mindestens ein version-tag in Ihrem repo zu starten.

git tag -a v0.0.1

InformationsquelleAutor der Antwort cmcginty

Pfeil verarbeitet es auf eine interessante Weise.

In arrow/__init__.py:

__version__ = '0.8.0'
VERSION = __version__

In setup.py:

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

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

InformationsquelleAutor der Antwort Anto

1. Verwenden version.py Datei nur mit __version__ = <VERSION> param in der Datei. In der setup.py - Datei importieren, die __version__ param und setzen Sie den Wert in der setup.py - Datei wie folgt:
   version=__version__
2. Ein anderer Weg ist die Verwendung von nur einer setup.py - Datei mit version=<CURRENT_VERSION> - CURRENT_VERSION ist hardcoded.

Da wir nicht möchten, ändern Sie manuell die version der Datei jedes mal, wenn wir erstellen einen neuen tag bereit zu release eine neue Paket-version), können wir die folgenden..

Empfehle ich bumpversion Paket. Ich benutze es schon seit Jahren zu stoßen, eine version.

starten Sie, indem Sie version=<VERSION> zu Ihrem setup.py - Datei, wenn Sie es nicht haben bereits.

Sollten Sie ein kurzes Skript wie das jedes mal, wenn Sie stoßen eine version:

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

Fügen Sie dann eine Datei pro repo genannt: .bumpversion.cfg:

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

Hinweis:

• Können Sie __version__ parameter unter version.py - Datei, wie es wurde vorgeschlagen, in anderen Beiträgen und aktualisieren Sie die bumpversion-Datei wie folgt:
  [bumpversion:file:<RELATIVE_PATH_TO_VERSION_FILE>]
• Sie muss git commit oder git reset alles in deinem repo, andernfalls erhalten Sie eine schmutzige repo-Fehler.
• Stellen Sie sicher, dass Ihre virtuelle Umgebung enthält das Paket von bumpversion, ohne wird es nicht funktionieren.

InformationsquelleAutor der Antwort Oran