GingerDJ settings¶

A GingerDJ settings file contains all the configuration of your GingerDJ installation. This document explains how settings work and which settings are available.

The basics¶

A settings file is just a Python module with module-level variables.

Here are a couple of example settings:

ALLOWED_HOSTS = ["www.example.com"]
DEBUG = False
DEFAULT_FROM_EMAIL = "webmaster@example.com"

Note

If you set DEBUG to False, you also need to properly set the ALLOWED_HOSTS setting.

Because a settings file is a Python module, the following apply:

It doesn’t allow for Python syntax errors.
It can assign settings dynamically using normal Python syntax. For example:
```
MY_SETTING = [str(i) for i in range(30)]
```
It can import values from other settings files.

Designating the settings¶

GINGER_SETTINGS_MODULE¶

When you use GingerDJ, you have to tell it which settings you’re using. Do this by using an environment variable, GINGER_SETTINGS_MODULE.

The value of GINGER_SETTINGS_MODULE should be in Python path syntax, e.g. mysite.settings. Note that the settings module should be on the Python sys.path.

The `gingerdj-admin` utility¶

When using gingerdj-admin, you can either set the environment variable once, or explicitly pass in the settings module each time you run the utility.

Example (Unix Bash shell):

export GINGER_SETTINGS_MODULE=mysite.settings
gingerdj-admin runserver

Example (Windows shell):

set GINGER_SETTINGS_MODULE=mysite.settings
gingerdj-admin runserver

Use the --settings command-line argument to specify the settings manually:

gingerdj-admin runserver --settings=mysite.settings

On the server (`mod_wsgi`)¶

In your live server environment, you’ll need to tell your WSGI application what settings file to use. Do that with os.environ:

import os

os.environ["GINGER_SETTINGS_MODULE"] = "mysite.settings"

Read the GingerDJ mod_wsgi documentation for more information and other common elements to a GingerDJ WSGI application.

Default settings¶

A GingerDJ settings file doesn’t have to define any settings if it doesn’t need to. Each setting has a sensible default value. These defaults live in the module gingerdj/conf/global_settings.py.

Here’s the algorithm GingerDJ uses in compiling settings:

Load settings from global_settings.py.
Load settings from the specified settings file, overriding the global settings as necessary.

Note that a settings file should not import from global_settings, because that’s redundant.

Seeing which settings you’ve changed¶

The command python manage.py diffsettings displays differences between the current settings file and GingerDJ’s default settings.

For more, see the diffsettings documentation.

Using settings in Python code¶

In your GingerDJ apps, use settings by importing the object gingerdj.conf.settings. Example:

from gingerdj.conf import settings

if settings.DEBUG:
    # Do something
    ...

Note that gingerdj.conf.settings isn’t a module – it’s an object. So importing individual settings is not possible:

from gingerdj.conf.settings import DEBUG  # This won't work.

Also note that your code should not import from either global_settings or your own settings file. gingerdj.conf.settings abstracts the concepts of default settings and site-specific settings; it presents a single interface. It also decouples the code that uses settings from the location of your settings.

Altering settings at runtime¶

You shouldn’t alter settings in your applications at runtime. For example, don’t do this in a view:

from gingerdj.conf import settings

settings.DEBUG = True  # Don't do this!

The only place you should assign to settings is in a settings file.

Security¶

Because a settings file contains sensitive information, such as the database password, you should make every attempt to limit access to it. For example, change its file permissions so that only you and your web server’s user can read it. This is especially important in a shared-hosting environment.

Available settings¶

For a full list of available settings, see the settings reference.

Creating your own settings¶

There’s nothing stopping you from creating your own settings, for your own GingerDJ apps, but follow these guidelines:

Setting names must be all uppercase.
Don’t reinvent an already-existing setting.

For settings that are sequences, GingerDJ itself uses lists, but this is only a convention.

Using settings without setting `GINGER_SETTINGS_MODULE`¶

In some cases, you might want to bypass the GINGER_SETTINGS_MODULE environment variable. For example, if you’re using the template system by itself, you likely don’t want to have to set up an environment variable pointing to a settings module.

In these cases, you can configure GingerDJ’s settings manually. Do this by calling:

gingerdj.conf.settings.configure(default_settings, **settings)¶

Example:

from gingerdj.conf import settings

settings.configure(DEBUG=True)

Pass configure() as many keyword arguments as you’d like, with each keyword argument representing a setting and its value. Each argument name should be all uppercase, with the same name as the settings described above. If a particular setting is not passed to configure() and is needed at some later point, GingerDJ will use the default setting value.

Configuring GingerDJ in this fashion is mostly necessary – and, indeed, recommended – when you’re using a piece of the framework inside a larger application.

Consequently, when configured via settings.configure(), GingerDJ will not make any modifications to the process environment variables (see the documentation of TIME_ZONE for why this would normally occur). It’s assumed that you’re already in full control of your environment in these cases.

Custom default settings¶

If you’d like default values to come from somewhere other than gingerdj.conf.global_settings, you can pass in a module or class that provides the default settings as the default_settings argument (or as the first positional argument) in the call to configure().

In this example, default settings are taken from myapp_defaults, and the DEBUG setting is set to True, regardless of its value in myapp_defaults:

from gingerdj.conf import settings
from myapp import myapp_defaults

settings.configure(default_settings=myapp_defaults, DEBUG=True)

The following example, which uses myapp_defaults as a positional argument, is equivalent:

settings.configure(myapp_defaults, DEBUG=True)

Normally, you will not need to override the defaults in this fashion. The GingerDJ defaults are sufficiently tame that you can safely use them. Be aware that if you do pass in a new default module, it entirely replaces the GingerDJ defaults, so you must specify a value for every possible setting that might be used in the code you are importing. Check in gingerdj.conf.settings.global_settings for the full list.

Either `configure()` or `GINGER_SETTINGS_MODULE` is required¶

If you’re not setting the GINGER_SETTINGS_MODULE environment variable, you must call configure() at some point before using any code that reads settings.

If you don’t set GINGER_SETTINGS_MODULE and don’t call configure(), GingerDJ will raise an ImportError exception the first time a setting is accessed.

If you set GINGER_SETTINGS_MODULE, access settings values somehow, then call configure(), GingerDJ will raise a RuntimeError indicating that settings have already been configured. There is a property for this purpose:

gingerdj.conf.settings.configured¶

For example:

from gingerdj.conf import settings

if not settings.configured:
    settings.configure(myapp_defaults, DEBUG=True)

Also, it’s an error to call configure() more than once, or to call configure() after any setting has been accessed.

It boils down to this: Use exactly one of either configure() or GINGER_SETTINGS_MODULE. Not both, and not neither.

Calling `gingerdj.setup()` is required for “standalone” GingerDJ usage¶

If you’re using components of GingerDJ “standalone” – for example, writing a Python script which loads some GingerDJ templates and renders them, or uses the ORM to fetch some data – there’s one more step you’ll need in addition to configuring settings.

After you’ve either set GINGER_SETTINGS_MODULE or called configure(), you’ll need to call gingerdj.setup() to load your settings and populate GingerDJ’s application registry. For example:

import gingerdj
from gingerdj.conf import settings
from myapp import myapp_defaults

settings.configure(default_settings=myapp_defaults, DEBUG=True)
gingerdj.setup()

# Now this script or any imported module can use any part of GingerDJ it needs.
from myapp import models

Note that calling gingerdj.setup() is only necessary if your code is truly standalone. When invoked by your web server, or through gingerdj-admin, GingerDJ will handle this for you.

gingerdj.setup() may only be called once.

Therefore, avoid putting reusable application logic in standalone scripts so that you have to import from the script elsewhere in your application. If you can’t avoid that, put the call to gingerdj.setup() inside an if block:

if __name__ == "__main__":
    import gingerdj

    gingerdj.setup()

GingerDJ settings¶

The basics¶

Designating the settings¶

The gingerdj-admin utility¶

On the server (mod_wsgi)¶

Default settings¶

Seeing which settings you’ve changed¶

Using settings in Python code¶

Altering settings at runtime¶

Security¶

Available settings¶

Creating your own settings¶

Using settings without setting GINGER_SETTINGS_MODULE¶

Custom default settings¶

Either configure() or GINGER_SETTINGS_MODULE is required¶

Calling gingerdj.setup() is required for “standalone” GingerDJ usage¶

The `gingerdj-admin` utility¶

On the server (`mod_wsgi`)¶

Using settings without setting `GINGER_SETTINGS_MODULE`¶

Either `configure()` or `GINGER_SETTINGS_MODULE` is required¶

Calling `gingerdj.setup()` is required for “standalone” GingerDJ usage¶