Version number in Django applications

Question

I'm working on a Django application and I want to display the version of the application (such that people, who find bugs know the version of the application and can provide better bug reports).

Is there a universally accepted way to store version number in Django (I mean the version of my application, not Django) ?

https://stackoverflow.com/a/459185 – djvg Apr 09 '21 at 07:23 — djvg, Apr 09 '21 at 07:23

score 30 · Answer 1 · edited May 23 '17 at 11:55

I was looking for this exact same question, and found your question. The answer you accepted is not quite satisfactory to me.

I am working with django debugtoolbar, in there you can also show all versions of the apps used. I was wondering how to get the versions of my custom applications to show there as well.

Looking a bit further I found this question and answer: How to check the version of a installed application in Django in running time?

This answer however does not tell me where to put this __version__

So I looked in to an open application, which does show up in django toolbar. I looked in to the django restframework code, there I found out:

the version is put in the __init__.py file

(see https://github.com/tomchristie/django-rest-framework/blob/master/rest_framework/init.py)

and it is put here as:

__version__ = '2.2.7'
VERSION = __version__  # synonym

And after this, in his setup.py, he gets this version from this __init__.py : see: https://github.com/tomchristie/django-rest-framework/blob/master/setup.py

like this:

import re

def get_version(package):
    """
    Return package version as listed in `__version__` in `init.py`.
    """
    init_py = open(os.path.join(package, '__init__.py')).read()
    return re.match("__version__ = ['\"]([^'\"]+)['\"]", init_py).group(1)

version = get_version('rest_framework')

When using buildout and zestreleaser:

By the way, I am using buildout and zest.releaser for building and versioning.

In this case, above is a bit different (but basically the same idea):

see http://zestreleaser.readthedocs.org/en/latest/versions.html#using-the-version-number-in-setup-py-and-as-version

The version in setup.py is automatically numbered by setup.py, so in __init__.py you do:

import pkg_resources

__version__ = pkg_resources.get_distribution("fill in yourpackage name").version
VERSION = __version__  # synonym

Isn't there a better way to `get_version` than to parse your own python code with a regex? — talz, Dec 07 '20 at 19:20

score 25 · Answer 2 · edited Jun 25 '20 at 06:08

There are many places where you can store your app version number and a few methods that allow you to show it in django templates. A lot depends on the release tool you're using and your own preferences.

Below is the approach I'm using in my current project.

Put the version number into version.txt

I'm storing the app version number in the version.txt file. It's one of the locations the zest.releaser release tool (that I'm using) takes into account while doing a release.

The whole content of version.txt is just the app version number, for example: 1.0.1.dev0

Read the number to a variable in settings.py

...    
with open(version_file_path) as v_file:
    APP_VERSION_NUMBER = v_file.read()
...

Create a custom context processor

This paragraph and the following ownes are based on the wonderful answer by bcchun to Can I access constants in settings.py from templates in Django?

A custom context processor will allow you to add the app version number to the context of every rendered template. You won't have to add it manually every time you render a template (and usually you'll want to have the version number somewhere in the footer of every page).

Create context_processors.py file in your app directory:

from django.conf import settings

def selected_settings(request):
    # return the version value as a dictionary
    # you may add other values here as well
    return {'APP_VERSION_NUMBER': settings.APP_VERSION_NUMBER}

Add the context processor to settings.py

TEMPLATES = [{
    ...
    'OPTIONS': {
        'context_processors': [
            ...
            'your_app.context_processors.selected_settings'
        ],
    },
 }]

Use `RequestContext` or `render` in views

RequestContext and render populate the context with variables supplied by context_processors you set in settings.py.

Example:

def some_view(request):
    return render(request, 'content.html')

Use it in a template

...
<div>{% trans 'App version' %}:{{APP_VERSION_NUMBER}}</div>
....

score 11 · Answer 3 · edited Oct 19 '22 at 23:29

11

For me the best result/approach is to use the __init__.py on the project folder, such as

.
├── project_name
│   ├── __init__.py

and later check using the standar way, as said in (PEP396)

>>> import project_name
>>> project_name.__version__
'1.0.0'

edited Oct 19 '22 at 23:29

LuxuryMode

33,401
34
117
188

answered Aug 26 '14 at 14:25

NeoMorfeo

300
1
3
14

score 9 · Answer 4 · answered May 10 '14 at 18:18

9

I solved this by adding a templatetag to my django project:

in proj/templatetags, added version.py:

from django import template
import time
import os

register = template.Library()

@register.simple_tag
def version_date():
    return time.strftime('%m/%d/%Y', time.gmtime(os.path.getmtime('../.git')))

Then, in my base.html (or whichever template), adding:

{% load version %}
<span class='version'>Last Updated: {% version_date %}</span>

answered May 10 '14 at 18:18

JayCrossler

2,079
2
22
22

That's a pretty interesting answer - I like the git plugin. – bbengfort Jan 22 '15 at 20:40
Great answer !! – Essex Apr 20 '17 at 11:25
I think this is the best one because contrary to other solutions, you don´t need to modify your views (which can be cumbersome if you have a lot of them!). Simply change the base template, I love it! – ThePhi Apr 22 '21 at 10:05

Mario Orlandi · Answer 5 · 2019-11-28T07:19:21.293

8

If using GIT for source versioning, you might want manual promotion of stable releases, and automatic numbering for development commits.

One why to obtain this in a Django project is:

In "PROJECT/_ init _.py" define:

__version__ = '1.0.1'
__build__ = ''

Then in setting.py do:

import os
import subprocess
import PROJECT

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

try:
    PROJECT.__build__ = subprocess.check_output(["git", "describe", "--tags", "--always"], cwd=BASE_DIR).decode('utf-8').strip()
except:
    PROJECT.__build__ = PROJECT.__version__ + " ?"

Thus, PROJECT._ build _ will show:

v1.0.1 in stable releases

and

v1.0.1-N-g8d2ec45

when the most recent tag doesn't point to the last commit (where N counts the number of additional commits after tag, followed by commit signature)

edited Nov 28 '19 at 07:19

answered Sep 15 '17 at 10:56

Mario Orlandi

5,629
26
29

1

Elegant, I like this. Thanks for sharing. – Dário Jan 30 '19 at 14:34
I would only add `.strip()` after `.decode('utf-8')`. – Dário Jan 30 '19 at 14:43
Thank you @Dário .. adding .strip() certainly wouldn't hurt, but in my opinion it wouldn't help either, as the output of "git describe" is predictable, and doesn't contain any trailing spaces. – Mario Orlandi Jan 31 '19 at 10:40
In recent projects, I started adding the "--always" option; this helps when no tag has been assigned yet – Mario Orlandi Jan 31 '19 at 10:43
1

Without `strip()` I was getting a trailing newline for some reason, didn't check why though. I'll try the `"--always"` option, sounds reasonable. Thanks. – Dário Jan 31 '19 at 18:55
1

mmhhh ... interesting ... strip() added ! Better safe then sorry, thank you @Dário – Mario Orlandi Feb 01 '19 at 08:46
1

I like this answer, but I needed to replace the first abspath with dirname for it to work – deMangler Nov 27 '19 at 19:54
1

Thank you @deMangler. In my projects, I usually move "down" the default "settings.py" file into a "project/settings" folder (actually, a module). That's why I then need to adjust the definition for BASE_DIR. I edited my comment to restore the more common expression as given by the "startproject" command. – Mario Orlandi Nov 28 '19 at 07:30

score 7 · Accepted Answer · edited May 23 '17 at 11:55

7

It seems the settings file would be a reasonable location to store the version number. I don't believe there is any Django accepted way to store a version number of your personal application. It seems like an application specific variable that you should define.

For more information on getting the version number out of svn: Getting SVN revision number into a program automatically

edited May 23 '17 at 11:55

Community

1
1

answered Jan 29 '13 at 19:23

tdedecko

1,442
10
15

danorton · Answer 7 · 2013-08-19T16:34:23.867

2

Not for Django applications, per se, but for Python modules, yes. See PEP 396, PEP 386 and the verlib library (easy_install verlib).

(I’d elaborate, but I just now discovered this, myself.)

edited Aug 19 '13 at 16:34

answered Aug 19 '13 at 16:12

danorton

11,804
7
44
52

score 1 · Answer 8 · answered May 07 '19 at 02:13

Version info is typically maintained in git commit tags. Else, even git commits and last updated time is a good indicator of which version is running and when it was deployed.

For those using django-rest-framework and only having an API, you can return both of these; "last updated" as well as "last git commit" using an /api/version endpoint:

In views.py:

import os
import time
import subprocess
import json

class VersionViewSet(ViewSet):
    def list(self, request):
        # ['git', 'describe', '--tags'] # use this for named tags (version etc)
        # ['git', 'describe', '--all', '--long'] # use this for any commit
        # git log -1 --pretty=format:"Last commit %h by %an, %ar ("%s")"
        # {"commit_hash": "%h", "full_commit_hash": "%H", "author_name": "%an", "commit_date": "%aD", "comment": "%s"}
        FILE_DIR = os.path.dirname(os.path.abspath(__file__))
        git_command = ['git', 'log', '-1', '--pretty={"commit_hash": "%h", "full_commit_hash": "%H", "author_name": "%an", "commit_date": "%aD", "comment": "%s"}']
        git_identifier = subprocess.check_output(git_command, cwd=FILE_DIR).decode('utf-8').strip()
        git_identifier = json.loads(git_identifier)
        last_updated = time.strftime('%a, %-e %b %Y, %I:%M:%S %p (%Z)', time.localtime(os.path.getmtime('.git'))).strip()
        return Response({
            "last_updated": last_updated,
            "git_commit": git_identifier
        }, status=200)

In urls.py:

from myapp.views import VersionViewSet

router = routers.DefaultRouter()
...
router.register(r'version', VersionViewSet, base_name='version')

This creates the endpoint in line with the other endpoints in your API.

Output will be seen like this at http://www.example.com/api/version/:

HTTP 200 OK
Allow: GET, HEAD, OPTIONS
Content-Type: application/json
Vary: Accept

{
    "last_updated": "Mon, 6 May 2019, 11:19:58 PM (IST)",
    "git_commit": {
        "commit_hash": "e265270",
        "full_commit_hash": "e265270dda196f4878f4fa194187a3748609dde0",
        "author_name": "Authorname",
        "commit_date": "Mon, 6 May 2019 23:19:51 +0530",
        "comment": "The git commit message or subject or title here"
    }
}

marquicus · Answer 9 · 2019-07-04T16:13:01.693

1

I use this option __import__('project').VERSION or __import__('project').__version__. The version is put in the __init__.py file as everybody said, for example:

proyect_name
  | __init__.py

# __init__.py file
VERSION = '1.0.0' # or __version__ = '1.0.0'

Now from everywhere you can get it:

# Error tracking settings
sentry_sdk.init(
    ...
    release=__import__('cjvc_project').VERSION
)

edited Jul 04 '19 at 16:13

answered Jul 04 '19 at 15:53

marquicus

180
2
5

score 0 · Answer 10 · answered Aug 18 '18 at 01:11

I used a context processor and it looks like this:

import sys
sys.path.append('..')

from content_services import __version__


def get_app_version(request):
    """
    Get the app version
    :param request:
    :return:
    """
    return {'APP_VERSION': __version__}

Since the project name is content_services I have to change the sys path up 1 level so I can import it.

mrts · Answer 11 · 2019-01-01T10:44:05.350

In case you use Git and version tagging you can display the application version in admin site header.

Create a version.py file in the project or any app module:

import os
import subprocess

FILE_DIR = os.path.dirname(os.path.abspath(__file__))


def get_version_from_git():
    try:
        return subprocess.check_output(['git', 'describe', '--tags'],
                                       cwd=FILE_DIR).decode('utf-8').strip()
    except:
        return '?'


VERSION = get_version_from_git()

Add the version to admin site header in urls.py:

from django.contrib import admin
from django.utils.safestring import mark_safe

from utils import version

...

admin.site.site_header = mark_safe('MyApp admin <span style="font-size: x-small">'
                                   f'({version.VERSION})</span>')

If you need to provide the version to external tools like Django Debug Toolbar, you can expose the version in project __init__.py as suggested above:

from utils import version

__version__ = version.VERSION
VERSION = __version__  # synonym

Version number in Django applications

11 Answers11

Put the version number into version.txt

Read the number to a variable in settings.py

Create a custom context processor

Add the context processor to settings.py

Use `RequestContext` or `render` in views

Use it in a template

Linked

Version number in Django applications

11 Answers11

Put the version number into version.txt

Read the number to a variable in settings.py

Create a custom context processor

Add the context processor to settings.py

Use RequestContext or render in views

Use it in a template

Linked

Use `RequestContext` or `render` in views