How can I rewrite python __version__ with git?

For those finding this question in 2018 you can also use Versioneer. Once enabled, it automatically sets version in setup.py and __version__ in your module based on the latest Git tag at time of build.

For example, if you build your project at tag 1.0.0, Versioneer will set the project’s version to 1.0.0. If you do two more commits, edit some without checking in, and build, Versioneer will set the version to something like 1.0.0+2.g1076c97.dirty.

Of course you can customize which tags Versioneer recognizes as version tags.

This is also how larger projects like pandas and matplotlib handle their versioning.

Another possibility other than Versioneer is setuptools_scm.

I have successfully implemented something very similar to the OP by adding the following to setup.py (or by modifying it accordingly):

from setuptools import setup
setup(
    ...,
    use_scm_version=True,
    setup_requires=['setuptools_scm'],
    ...,
)

and, in order to have __version__ updated automatically, added this to __init__.py of my package:

from pkg_resources import get_distribution, DistributionNotFound
try:
    __version__ = get_distribution(__name__).version
except DistributionNotFound:
    # package is not installed
    pass

You can use the following code to retrieve your current git commit version (reported as either a commit id on a branch or as a tag if a tag has been added:

from git import Repo

def GetGitVersion():
    '''report the git commit/branch/tag on which we are '''
    repo = Repo(".", search_parent_directories=True)
    git = repo.git    

    branchOrTag=git.rev_parse('--abbrev-ref', 'HEAD')

    if branchOrTag == 'HEAD':
        # get tag name
        # since several tags are sometime put on the same commit we want to retrieve all of them
        # and use the last one as reference
        # Note:
        # branchOrTag=`git describe --tags --exact-match` does not provided the latest created tag in case several point to the same place
        currentSha=git.rev_parse('--verify','HEAD')

        # list all tags on the current sha using most recent first:
        allTags=git.tag('--points-at',currentSha,'--sort=-creatordate')
        print (allTags)

        allTagsArray=allTags.split(' ') #create an array (assuming tags are separated by space)

        # if we checkouted a commit with no tag associated, the allTagsArray is empty we can use directly the sha value
        if len(allTagsArray) == 0:
            branchOrTag=git.rev-rev_parse('--short','HEAD') # take the short sha
        else:

            branchOrTag=allTagsArray[0] #first from the list
    else:
        #add the head commit id on the current branch
        branchOrTag="{}[{}]".format(branchOrTag,git.rev_parse('--short', 'HEAD'))

    return branchOrTag
if __name__ == "__main__":
    print (GetGitVersion())

(1) One option is to get the version number in real-time from the release version written into a published package. To do this, you would add a dependency to __init__.py, release the product with something like setup.py and at runtime execute python3 setup.py --version. This approach uses the lightweight importlib_metadata module [importlib_metadata (for pre Python 3.8) and importlib.metadata (for Python 3.8+)]:

from importlib.metadata import version, PackageNotFoundError
# pre-3.8 import statement
# from importlib_metadata import version, PackageNotFoundError

VERSION_FALLBACK = "0.0.0"
try:
    __version__ = version(__name__)
except PackageNotFoundError:
    # package is not installed
    # assign signal or sane value as a default
    __version__ = VERSION_FALLBACK
    pass

This implements metadata recommendations from PEP 566. If you release with setuptools>=42.0.0 this works great, and it may work with packages released by other tooling, also.

(2) A second option is to do something with Git to collect the last tag value (assuming you are tagging the application). Then increment the point version number. Then replace the value in the init file with the new value and tag with the new value.

# get and increment semantic version
version=$( git tag --list | sort -rV | head -1 );  # v0.1.1
version_point=${version##*.}  # 1
version_point=$((${version_point} + 1))  # 2
version="${version%.*}.${version_point}"  # v0.1.2
# replace in __init__.py (NOTE: THIS OVERWRITES!)
cat __init.py__ | sed -e "s/VERSION=.*/VERSION=${version}/i" > __init__.py
git add __init__.py && git commit -m "Updated version in __init__.py"
git tag -a ${version} -m "Latest tagged version"

My approach has been to package a file ‘version.txt’ in a directory (say "metadata") which contains the output from the command

git describe --long --tags --dirty --always >metadata/version.txt

together with the Python source files.

In the script that runs the Python application, there is then a command to

export GIT_VERSION=`cat metadata/version.txt`

running just before the application is started.

The code can then on startup run

git_version = os.getenv('GIT_VERSION', None)

to read