how to modularize django

Each Answer to this Q is separated by one/two green lines.

When you install a new django application, you have to add/modify your module.

For a project I’m trying to make that module a python subpackage and create a module for each application:


The problem I’m confronted with is how to merge attributes (INSTALLED_APPS for example is a tuple of values) that are getting values in the different submodules?


Ok, I asked the wrong question (got the right answer for it though). My question should have been, how to get attributes from all submodules and merge them? Django will import settings and expects everything to be there.

“When you install a new django application, you have to add/modify your module.”

I think this is fine as is.

I don’t see any reason to change or modify this at all.

What we do, however, is to “subclass” the core settings module.

Our developer-specific and installation-specific files have names like settings_devxy_linux2 and settings_checkout_win32, etc.

Each of these files starts with from settings import * to import the core settings and extend those core settings with overrides for a specific installation and platform.

It doesn’t require any real work. It does, however, mean that we do most things with because our settings aren’t called settings.

You might be interested in this solution; uses execfile() to load a series of settings files in order, where each file has full access to settings from previously-loaded files, to update, modify, etc.

I’ve used this work-around:

INSTALLED_APPS = ('whatever',)
import more_settings

def modify(settings):
    settings['INSTALLED_APPS'] += ('another_app',)

I created as my preferred solution. Allows for inheritance from a common file in any deployment environment.

I have the same structure of settings files and I do the following to import the settings of the submodules:

def load_settings_file(file):
    file = open(os.path.join(INSTALL_DIR, '<projectname>', 'settings', file + '.py'))
    content =
    return content

for submodule in ['base', 'admin', 'feincms']:

If you prefer more magic than in my previous more_settings.modify() approach, try this:

INSTALLED_APPS = ('whatever',)
import more_settings

def config(INSTALLED_APPS=(), **other_settings):
    INSTALLED_APPS += ('another_app',)
    del other_settings
    return locals()

def modify(settings):

Pros: no need to refer to settings with dict notation

Cons: must define modified settings as kwargs for config()

Presumably the best way to “merge” varies, attributes by attributes. For example, given several tuples (from the INSTALLED_APPS of various submodules), you might simply concatenate them into a new tuple (for the INSTALLED_APPS attribute of the package as a whole), or, if possible duplications are a problem, so something smarter to remove the duplications (in this case you may not care about ordering, so simply tuple(set(tup1+tup2+tup3)) might suffice).

For other cases (“merging” dictionaries, “merging” settings which are just scalars or strings, etc) you’ll need different strategies (maybe successive .update calls for the dictionaries, pick just one according to some criteria for the scalars or strings, etc, etc) — I just don’t see a “one size fits all” approach working here.

just put

from base import *
from admin import *

in ur
that should work

i used it for different sites

base/ # common settings: db, apps, ...
base/sites/website1/ # site_id, custom middleware 
base/sites/website2/ # site_id, custom middleware

the website settings import the common settings with

from base.settings import *

and define custom attribtues

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .