| 1 |
import datetime |
| 2 |
import functools |
| 3 |
import os |
| 4 |
import subprocess |
| 5 |
import sys |
| 6 |
|
| 7 |
from django.utils.regex_helper import _lazy_re_compile |
| 8 |
|
| 9 |
# Private, stable API for detecting the Python implementation. |
| 10 |
PYPY = sys.implementation.name == "pypy" |
| 11 |
|
| 12 |
# Private, stable API for detecting the Python version. PYXY means "Python X.Y |
| 13 |
# or later". So that third-party apps can use these values, each constant |
| 14 |
# should remain as long as the oldest supported Django version supports that |
| 15 |
# Python version. |
| 16 |
PY38 = sys.version_info >= (3, 8) |
| 17 |
PY39 = sys.version_info >= (3, 9) |
| 18 |
PY310 = sys.version_info >= (3, 10) |
| 19 |
PY311 = sys.version_info >= (3, 11) |
| 20 |
PY312 = sys.version_info >= (3, 12) |
| 21 |
PY313 = sys.version_info >= (3, 13) |
| 22 |
PY314 = sys.version_info >= (3, 14) |
| 23 |
|
| 24 |
|
| 25 |
def get_version(version=None): |
| 26 |
"""Return a PEP 440-compliant version number from VERSION.""" |
| 27 |
version = get_complete_version(version) |
| 28 |
|
| 29 |
# Now build the two parts of the version number: |
| 30 |
# main = X.Y[.Z] |
| 31 |
# sub = .devN - for pre-alpha releases |
| 32 |
# | {a|b|rc}N - for alpha, beta, and rc releases |
| 33 |
|
| 34 |
main = get_main_version(version) |
| 35 |
|
| 36 |
sub = "" |
| 37 |
if version[3] == "alpha" and version[4] == 0: |
| 38 |
git_changeset = get_git_changeset() |
| 39 |
if git_changeset: |
| 40 |
sub = ".dev%s" % git_changeset |
| 41 |
|
| 42 |
elif version[3] != "final": |
| 43 |
mapping = {"alpha": "a", "beta": "b", "rc": "rc"} |
| 44 |
sub = mapping[version[3]] + str(version[4]) |
| 45 |
|
| 46 |
return main + sub |
| 47 |
|
| 48 |
|
| 49 |
def get_main_version(version=None): |
| 50 |
"""Return main version (X.Y[.Z]) from VERSION.""" |
| 51 |
version = get_complete_version(version) |
| 52 |
parts = 2 if version[2] == 0 else 3 |
| 53 |
return ".".join(str(x) for x in version[:parts]) |
| 54 |
|
| 55 |
|
| 56 |
def get_complete_version(version=None): |
| 57 |
""" |
| 58 |
Return a tuple of the django version. If version argument is non-empty, |
| 59 |
check for correctness of the tuple provided. |
| 60 |
""" |
| 61 |
if version is None: |
| 62 |
from django import VERSION as version |
| 63 |
else: |
| 64 |
assert len(version) == 5 |
| 65 |
assert version[3] in ("alpha", "beta", "rc", "final") |
| 66 |
|
| 67 |
return version |
| 68 |
|
| 69 |
|
| 70 |
def get_docs_version(version=None): |
| 71 |
version = get_complete_version(version) |
| 72 |
if version[3] != "final": |
| 73 |
return "dev" |
| 74 |
else: |
| 75 |
return "%d.%d" % version[:2] |
| 76 |
|
| 77 |
|
| 78 |
@functools.lru_cache |
| 79 |
def get_git_changeset(): |
| 80 |
"""Return a numeric identifier of the latest git changeset. |
| 81 |
|
| 82 |
The result is the UTC timestamp of the changeset in YYYYMMDDHHMMSS format. |
| 83 |
This value isn't guaranteed to be unique, but collisions are very unlikely, |
| 84 |
so it's sufficient for generating the development version numbers. |
| 85 |
""" |
| 86 |
# Repository may not be found if __file__ is undefined, e.g. in a frozen |
| 87 |
# module. |
| 88 |
if "__file__" not in globals(): |
| 89 |
return None |
| 90 |
repo_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| 91 |
git_log = subprocess.run( |
| 92 |
"git log --pretty=format:%ct --quiet -1 HEAD", |
| 93 |
capture_output=True, |
| 94 |
shell=True, |
| 95 |
cwd=repo_dir, |
| 96 |
text=True, |
| 97 |
) |
| 98 |
timestamp = git_log.stdout |
| 99 |
tz = datetime.timezone.utc |
| 100 |
try: |
| 101 |
timestamp = datetime.datetime.fromtimestamp(int(timestamp), tz=tz) |
| 102 |
except ValueError: |
| 103 |
return None |
| 104 |
return timestamp.strftime("%Y%m%d%H%M%S") |
| 105 |
|
| 106 |
|
| 107 |
version_component_re = _lazy_re_compile(r"(\d+|[a-z]+|\.)") |
| 108 |
|
| 109 |
|
| 110 |
def get_version_tuple(version): |
| 111 |
""" |
| 112 |
Return a tuple of version numbers (e.g. (1, 2, 3)) from the version |
| 113 |
string (e.g. '1.2.3'). |
| 114 |
""" |
| 115 |
version_numbers = [] |
| 116 |
for item in version_component_re.split(version): |
| 117 |
if item and item != ".": |
| 118 |
try: |
| 119 |
component = int(item) |
| 120 |
except ValueError: |
| 121 |
break |
| 122 |
else: |
| 123 |
version_numbers.append(component) |
| 124 |
return tuple(version_numbers) |