Convention Over Configuration: Django Settings
I’ve been working with Django for over five years. Even though I don’t consider myself as a programmer, one of the advantages I seem to have over less experienced Django developers is that I’ve developed (together with our team) strong conventions on how I work. This makes developing faster and generally more enjoyable.
Conventions are a tool for efficient workflow and to help read and understand code by other people better. Like so many tools, conventions too can be taken to extremes to the point when then they become magic (Rails, anyone), which in Python community is considered a bad practice.
The Python community has a name for code that feels right: that kind of code is pythonic. Good, pythonic conventions are logical and easy to remember but also explicit. In other words good conventions should make sense when you see them first time.
Django has many documented conventions (like that models should live in
models.py and views in
views.py) and even coding guidelines but there are many places that could use more stronger or better ones. This article is first in a series of discussing conventions related to Django. My goal is not to impose these opinnions to anyone but to share what I’ve learned while working with Django for over five years.
Conventions for Django settings
Settings are not the sharpest tool in the Django shed. This article is not about crying over the design details, but to make working with them easier.
Always use relative paths
One of the first hurdles one comes up with Django settings is that they aren’t very portable. The
TEMPLATE_DIRS settings are problematic because the given examples are absolute paths (like
"/home/media/media.lawrence.com/media/"). Simply by defining your paths as relative you can free yourself from this and move your projects around without breaking your settings.
A good convention is to define a
PROJECT_ROOT setting and make every path in your settings relative to that root. Django settings file is just an ordinary Python module (well, not really, but in this respect it is) so you can use Python to do this:
import os PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')) MEDIA_ROOT = os.path.join(PROJECT_ROOT, 'media')
Turn settings into a package
Second problem you almost immediately have is a problem of multiple settings files. You can make your life a lot easier by moving settings from ´settings.py´ into several different files in a directory called settings. (Remember that to python
/path/to/your_project/settings/__init__.py are the same thing.)
Also, because there usually is at least two almost equal settings files (for development and production), it’s smart to differentiate common settings and the ones that change for every machine. For this, you can move common settings to
common_settings.py and then just import that to your other settings files:
from common_settings import *
Now you can either add an empty
__init__.py to the settings directory and refer to settings as
DJANGO_SETTINGS_MODULE=myproject.settings.myenv or you can symlink the current environment settings as
You could end up with a directory structure like this:
myproject/ manage.py urls.py settings/ __init__.py common_settings.py dev_adrian.py dev_jacob.py dev_simon.py production.py staging.py
Now you have one file for common settings and one for each individual environment and they all can live together in version control.
Store sensitive data outside of settings files
Another problematic thing about Django settings is that you’re supposed to put things like passwords and API-keys in there. For development environment this seldomly is a problem but what about version control and different settings for staging and production environments?
At this point it is a no-brainer: just put all sensitive data to a file outside of version control and import that:
from secrets import *
Now we don’t need to think about storing sensitive data in the version control and we just need to make sure that
secrets.py is properly protected in the production environment.
Conventions are good and we need them. By using these few simple conventions you can make your Django projects more portable, secure and pythonic.
More important than the implemention details is that you follow some conventions. I’m a strong believer of customization and that you should make your own conventions that best fit you yourself or your team. (This, obviously, is not something you shouldn’t do when writing your first Django apps but instead when you have been working with Django a while so that you have a general feeling of what works for you and what doesn’t.)
Next in the series I’ll talk about arranging the overall project structure and the tools that help keeping your project evolving.
Meanwhile, any comments or tips that you’d like to share?