Django Nine

0.2.7 · maintenance · verified Fri Apr 17

django-nine is a lightweight utility library for Django that provides consistent methods for checking Django and Python versions, as well as abstracting user model access for cross-version compatibility. The current version is 0.2.7. Its release cadence is very slow, with the last update in late 2022.

Common errors

```
ModuleNotFoundError: No module named 'django_nine'
```
cause Incorrect import statement; the package is installed as `django-nine` but imported as `nine`.

fix Change your import statement from `import django_nine` or `from django_nine import ...` to `import nine` or `from nine import ...`.
```
ModuleNotFoundError: No module named 'packaging'
```
cause The `packaging` dependency was introduced in `django-nine` 0.2.7. If you installed an older version and upgraded Python/Django without properly reinstalling, or if pip resolution failed, `packaging` might be missing.

fix Ensure `packaging` is installed: `pip install packaging` or reinstall `django-nine` to pick up its dependencies: `pip install --upgrade django-nine`.
```
AttributeError: module 'nine.versions' has no attribute 'DJANGO_GTE_X_Y'
```
cause You are attempting to access a version constant (e.g., `DJANGO_GTE_3_0`) that is not available in your installed `django-nine` version, or you have a typo in the constant name.

fix Check the `django-nine` documentation or source code for available constants, and ensure you have an updated version of `django-nine` if looking for newer Django version constants. For example, `DJANGO_GTE_2_0` is available, but `DJANGO_GTE_4_0` might only be present in very recent versions (or not at all if the library hasn't updated).

Warnings

gotcha The PyPI package is `django-nine`, but the Python import name is `nine`. Attempting to import `django_nine` will result in a `ModuleNotFoundError`.
Fix: Always use `from nine import ...` for imports.
breaking As of version 0.2.7, `django-nine` officially dropped support and testing for Python 2.x and older Python 3 versions (3.4, 3.5, 3.6), as well as very old Django versions. While the code might still function on some of these, it's no longer guaranteed.
Fix: Ensure your project uses Python 3.7+ and a modern Django version (e.g., Django 2.2+).
gotcha `Django` is a peer dependency, meaning `django-nine` expects Django to be installed in your environment, but it does not install Django for you. If Django is not installed, the utilities will not function correctly.
Fix: Explicitly install Django alongside `django-nine` (e.g., `pip install django django-nine`).

Install

pip install django-nine Install stable version

Imports

versions
wrong:
```
from django_nine import versions
```
correct:
```
from nine import versions
```
The installed package is `django-nine` but the top-level import name is `nine`.
user
wrong:
```
from django_nine import user
```
correct:
```
from nine import user
```
The installed package is `django-nine` but the top-level import name is `nine`.

Quickstart

This quickstart demonstrates how to use `django-nine` to check the Django version and access the user model. The `versions` module provides boolean constants for easy version comparisons.

from nine import versions
from nine import user
import django

print(f"Current Django version: {django.get_version()}")

if versions.DJANGO_GTE_1_7:
    print("Django version is 1.7 or greater.")

if versions.DJANGO_GTE_2_0:
    print("Django version is 2.0 or greater.")

# Example of getting user model for cross-version compatibility
# (Requires Django to be configured, typically inside a Django project)
# from django.conf import settings
# settings.configure() # Only for standalone script, not a real Django project
# try:
#    User = user.get_user_model()
#    print(f"User model: {User._meta.label}")
# except Exception as e:
#    print(f"Could not get user model: {e}")

view raw JSON →