Comment puis-je obtenir la version définie dans setup.py (setuptools) dans mon colis?

exemple d'étude: mymodule

Imaginer cette configuration:

setup.py
mymodule/
        / __init__.py
        / version.py
        / myclasses.py

Alors imaginez un scénario où vous avez des dépendances et setup.py ressemble:

setup(...
    install_requires=['dep1','dep2', ...]
    ...)

Et un exemple __init__.py:

from mymodule.myclasses import *
from mymodule.version import __version__

Et par exemple myclasses.py:

# these are not installed on your system.
# importing mymodule.myclasses would give ImportError
import dep1
import dep2

le problème n ° 1: importation de mymodule lors de l'installation

Si votre setup.py importations mymodule puis lors de l'installation vous serait le plus susceptible d'obtenir un ImportError. C'est une erreur très commune lorsque votre colis a des dépendances. Si votre colis n'ont pas d'autres dépendances que les objets internes, vous pouvez être sûr; mais ce n'est pas une bonne pratique. La raison pour cela est qu'il n'est pas de l'avenir; dire demain, votre code doit consommer certains autres dépendances.

problème #2: où est mon __version__ ?

Si vous coder en dur __version__ dans setup.py alors il peut ne pas correspondre à la version que vous serait livré dans votre module. Pour être cohérent, vous le mettez dans un endroit et de le lire à partir de la même place quand vous en avez besoin. À l'aide de import vous pouvez obtenir le problème n ° 1.

solution: à la setuptools

Vous devez utiliser une combinaison de open, exec et de fournir un dict pour exec pour ajouter des variables:

# setup.py
from setuptools import setup, find_packages
from distutils.util import convert_path

main_ns = {}
ver_path = convert_path('mymodule/version.py')
with open(ver_path) as ver_file:
    exec(ver_file.read(), main_ns)

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

Et dans mymodule/version.py exposer la version:

__version__ = 'some.semantic.version'

De cette façon, la version est livré avec le module, et vous n'avez pas de problèmes lors de l'installation d'essayer d'importer un module de dépendances manquantes (pas encore installé).

Votre question est un peu vague, mais je pense que ce que vous demandez est de savoir comment le spécifier.

Vous devez définir __version__ comme suit:

__version__ = '1.4.4'

Et ensuite, vous pouvez confirmer que setup.py sait à propos de la version que vous venez de spécifier:

% ./setup.py --version
1.4.4

De créer un fichier dans l'arborescence des sources, par exemple dans yourbasedir/yourpackage/_version.py . Laissez ce fichier ne contient qu'une seule ligne de code, comme ceci:

__version__ = "1.1.0-r4704"

Puis dans votre setup.py, ouvrez ce fichier et d'analyser le numéro de version comme ceci:

verstr = "inconnu" 
essayez: 
verstrline = open('yourpackage/_version.py', "rt").lire() 
sauf EnvironmentError: 
pass # d'Accord, il n'y a pas de version de fichier. 
autre chose: 
VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]" 
mo = re.recherche(VSRE, verstrline, re.M) 
si mo: 
verstr = mo.groupe(1) 
autre chose: 
soulever RuntimeError("impossible de trouver la version en yourpackage/_version.py") 

Enfin, dans yourbasedir/yourpackage/__init__.py importation _version comme ceci:

__version__ = "inconnu" 
essayez: 
de _version importer __version__ 
sauf ImportError: 
# Nous sommes en cours d'exécution dans un arbre qui n'a pas un _version.py, de sorte que nous ne savons pas ce que notre version est. 
passer 

Un exemple de code qui fait ce est le "pyutil" paquet que je maintiens. (Voir PyPI ou de recherche de google -- stackoverflow est me refusant d'inclure un lien hypertexte dans cette réponse.)

@pjeby est juste que vous ne devriez pas importer votre colis à partir de ses propres setup.py. Qui va travailler quand vous le tester en créant un nouvel interpréteur Python et de l'exécution de setup.py dans la première chose: python setup.py, mais il ya des cas où ça ne marchera pas. C'est parce que import youpackage ne signifie pas pour lire le répertoire de travail courant pour un répertoire nommé "yourpackage", il signifie regarder dans le courant sys.modules pour une clé "yourpackage" et ensuite de faire différentes choses, si elle n'est pas là. De sorte qu'il fonctionne toujours lorsque vous ne python setup.py parce que vous avez une nouvelle, vide sys.modules, mais cela ne fonctionne pas en général.

Par exemple, si py2exe est de l'exécution de votre setup.py dans le cadre du processus de empaquetage d'une application? J'ai vu un cas comme ça où py2exe aurait mis le mauvais numéro de version sur un paquet parce que le paquet a été d'obtenir son numéro de version de import myownthing dans son setup.py mais une autre version de ce paquet avait déjà été importées au cours de la py2exe exécuter. De même, si setuptools, easy_install, distribuer, ou distutils2 est d'essayer de construire votre paquet dans le cadre d'un processus d'installation d'un package différent qui dépend de la vôtre? Alors que votre paquet est importable au moment de son setup.py est en cours d'évaluation, ou s'il existe déjà une version de votre colis qui a été importé au cours de cette interpréteur Python la vie, ou si l'importation de votre package requiert d'autres paquets à installer en premier, ou a des effets secondaires, peuvent modifier les résultats. J'ai eu plusieurs luttes à essayer de ré-utiliser les paquets Python qui a causé des problèmes pour les outils comme py2exe et setuptools parce que leur setup.py les importations de l'emballage lui-même afin de trouver son numéro de version.

Par ailleurs, cette technique joue bien avec les outils de création automatique de la yourpackage/_version.py fichier pour vous, par exemple par la lecture de votre contrôle de révision de l'histoire et de la rédaction d'un numéro de version sur la base des plus récentes balise dans le contrôle de révision de l'histoire. Voici un outil qui n'a que pour darcs: http://tahoe-lafs.org/trac/darcsver/browser/trunk/README.rst et voici un extrait de code qui fait la même chose pour git: http://github.com/warner/python-ecdsa/blob/0ed702a9d4057ecf33eea969b8cf280eaccd89a1/setup.py#L34

Avec une structure comme ceci:

setup.py
mymodule/
        / __init__.py
        / version.py
        / myclasses.py

où version.py contient:

__version__ = 'version_string'

Vous pouvez le faire dans setup.py:

import sys

sys.path[0:0] = ['mymodule']

from version import __version__

Cela ne cause pas de problème avec toutes les dépendances que vous avez dans votre mymodule/__init__.py

Il y a mille et une façons de la peau d'un chat -- voici la mienne:

# Copied from (and hacked):
# https://github.com/pypa/virtualenv/blob/develop/setup.py#L42
def get_version(filename):
    import os
    import re

    here = os.path.dirname(os.path.abspath(__file__))
    f = open(os.path.join(here, filename))
    version_file = f.read()
    f.close()
    version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]",
                              version_file, re.M)
    if version_match:
        return version_match.group(1)
    raise RuntimeError("Unable to find version string.")

Nous avons voulu mettre les méta-informations sur nos offres pypackagery dans __init__.py, mais ne pouvait pas car il a de la troisième partie des dépendances que PJ Eby l'a déjà souligné (voir sa réponse et l'avertissement concernant la condition de la course).

Nous l'avons résolu en créant un module séparé pypackagery_meta.py qui contient seulement les méta-informations:

"""Define meta information about pypackagery package."""

__title__ = 'pypackagery'
__description__ = ('Package a subset of a monorepo and '
                   'determine the dependent packages.')
__url__ = 'https://github.com/Parquery/pypackagery'
__version__ = '1.0.0'
__author__ = 'Marko Ristin'
__author_email__ = '[email protected]'
__license__ = 'MIT'
__copyright__ = 'Copyright 2018 Parquery AG'

ensuite importé le méta-informations dans packagery/__init__.py:

# ...

from pypackagery_meta import __title__, __description__, __url__, \
    __version__, __author__, __author_email__, \
    __license__, __copyright__

# ...

et enfin utilisé dans setup.py:

import pypackagery_meta

setup(
    name=pypackagery_meta.__title__,
    version=pypackagery_meta.__version__,
    description=pypackagery_meta.__description__,
    long_description=long_description,
    url=pypackagery_meta.__url__,
    author=pypackagery_meta.__author__,
    author_email=pypackagery_meta.__author_email__,
    # ...
    py_modules=['packagery', 'pypackagery_meta'],
 )

Vous devez inclure pypackagery_meta dans votre forfait avec py_modules installation argument. Sinon, vous ne pouvez pas importer lors de l'installation depuis le package de distribution en manque.

Simple et droite, créez un fichier appelé source/package_name/version.py avec le contenu suivant:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
__version__ = "2.6.9"

Ensuite, sur votre fichier source/package_name/__init__.py, de l'importation de la version pour d'autres personnes à utiliser:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
from .version import __version__

Maintenant, vous pouvez le mettre sur les setup.py

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import re
import sys

try:
    filepath = 'source/package_name/version.py'
    version_file = open( filepath )
    __version__ ,= re.findall( '__version__ = "(.*)"', version_file.read() )

except Exception as error:
    __version__ = "0.0.1"
    sys.stderr.write( "Warning: Could not open '%s' due %s\n" % ( filepath, error ) )

finally:
    version_file.close()

Testé avec Python 2.7, 3.3, 3.4, 3.5, 3.6 et 3.7 sur Linux, Windows et Mac OS. Je l'ai utilisé sur mon paquet de l'Intégration et des Tests Unitaires pour tous ces plates-formes. Vous pouvez voir les résultats de .travis.yml et appveyor.yml ici:

1. https://travis-ci.org/evandrocoan/debugtools/builds/527110800
2. https://ci.appveyor.com/project/evandrocoan/pythondebugtools/builds/24245446

---

Une autre version est à l'aide de gestionnaire de contexte:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import re
import sys

try:
    filepath = 'source/package_name/version.py'

    with open( filepath ) as file:
        __version__ ,= re.findall( '__version__ = "(.*)"', file.read() )

except Exception as error:
    __version__ = "0.0.1"
    sys.stderr.write( "Warning: Could not open '%s' due %s\n" % ( filepath, error ) )

Vous pouvez également utiliser l' codecs module pour gérer l'unicode des erreurs à la fois sur le langage Python 2.7 et 3.6

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import re
import sys
import codecs

try:
    filepath = 'source/package_name/version.py'

    with codecs.open( filepath, 'r', errors='ignore' ) as file:
        __version__ ,= re.findall( '__version__ = "(.*)"', file.read() )

except Exception as error:
    __version__ = "0.0.1"
    sys.stderr.write( "Warning: Could not open '%s' due %s\n" % ( filepath, error ) )

---

Si vous écrivez un module Python 100% en C/C++ à l'aide de Python, C Extensions, vous pouvez faire la même chose, mais à l'aide de C/C++ au lieu de Python.

Sur ce cas, créez le setup.py:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import re
import sys
import codecs
from setuptools import setup, Extension

try:
    filepath = 'source/version.h'

    with codecs.open( filepath, 'r', errors='ignore' ) as file:
        __version__ ,= re.findall( '__version__ = "(.*)"', file.read() )

except Exception as error:
    __version__ = "0.0.1"
    sys.stderr.write( "Warning: Could not open '%s' due %s\n" % ( filepath, error ) )

setup(
        name = 'package_name',
        version = __version__,

        package_data = {
                '': [ '**.txt', '**.md', '**.py', '**.h', '**.hpp', '**.c', '**.cpp' ],
            },

        ext_modules = [
            Extension(
                name = 'package_name',
                sources = [
                    'source/file.cpp',
                ],
                include_dirs = ['source'],
            )
        ],
    )

Qui lit la version du fichier version.h:

const char* __version__ = "1.0.12";

Mais, ne pas oublier de créer le MANIFEST.in pour inclure le version.h fichier:

include README.md
include LICENSE.txt

recursive-include source *.h

Et il est intégré dans l'application principale avec:

#include <Python.h>
#include "version.h"

//create the module
PyMODINIT_FUNC PyInit_package_name(void)
{
    PyObject* thismodule;
    ...

    //https://docs.python.org/3/c-api/arg.html#c.Py_BuildValue
    PyObject_SetAttrString( thismodule, "__version__", Py_BuildValue( "s", __version__ ) );

    ...
}

Références:

1. python ouvrir le fichier d'erreur
2. Définir un mondial dans un module Python à partir d'une API C
3. Comment inclure les données du paquet avec setuptools/distribuer?
4. https://github.com/lark-parser/lark/blob/master/setup.py#L4
5. Comment utiliser setuptools paquets et ext_modules avec le même nom?
6. Est-il possible d'inclure les sous-répertoires à l'aide de dist utils (setup.py) dans le cadre du paquet de données?