Usually this happens when you’re using so called in-project apps (apps reside inside project directory itself). It’s just because you have incorrect PYTHONPATH setting.

Whenever you run Django with ./manage.py runserver there happens two things. First Python will use current working directory as base search path. So first path to search is always ‘.’

The simple fix

To make it work you need to add your root to your project as well as project directory to PYTHONPATH, usually this is done in wsgi startup script.

import sys

# Required to make project.settings to work
sys.path.append('/path/to/root/')

# required to make myapp.models and like imports to work
sys.path.append('/path/to/root/project/')

Of course you can omit root and use only "settings" as a Django settings, but it has it's own caveats.

Personally I use out-of-project apps to avoid this particular problem. Of course it requires that in even in development phase I need to setup PYTHONPATH as well to make everything work, but it will be consistent - I need to set it up always, not just in deployment phase.

Note that this article only applies to DEBUG mode, not production mode.

Let’s start doing same thing as in tutorial and add serving static files when in debug mode. Add following lines in your top-level urls.py file:

from django.conf import settings

# ... your existing urls here

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^site_media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ROOT}),
    )

Most important thing here is to note url used. It’s /site_media/. You can change whatever you want, but note that by default admin uses ADMIN_MEDIA_PREFIX = ‘/media/‘. If you accidentally override admin media url you get unwanted results in admin.

Next you have to change your settings.py file to have these new settings.

MEDIA_URL = '/site_media/'
MEDIA_ROOT = '/absolute/path/to/media/root/'

MEDIA_URL is a url where your static files like CSS and images are going to be. MEDIA_ROOT is a path where your media files are located and where actually MEDIA_URL points to.

One useful trick to provide MEDIA_ROOT is to use “relative” path to your project (settings.py).

import os
MEDIA_ROOT = os.path.abspath(os.path.dirname(__file__) + '/site_media/')

Last thing is to make sure your templates are correctly done:

Use always context variable (and context processors) like:

css" href="{{ MEDIA_URL }}css/styles.css" />

<script type="text/<span class="><!--mce:0--></script>

<img src="{{ MEDIA_URL }}images/cat.png" />

In your view code you have to use following:

return render_to_response('mytemplate.html', {},
  context_instance=RequestContext(request))

How this all ties together?

MEDIA_URL points to /site_media/ which then is appended in templates to your urls making them like /site_media/images/cat.png. Regular expression extracts last parts of URL (images/cat.png) which is then in turn appended to MEDIA_ROOT path by Django built-in view.

This works with 1.1:

qs = MyModel.objects.filter(pk=1)
len(qs) # Evaluate queryset

from django.db import connection; print connection.queries[-1]

for Django 1.2 you do following (replace ‘default’ with name of db if you want to check some explicit db):

qs = MyModel.objects.filter(pk=1)
len(qs) # Evaluate queryset

from django.db import connections; print connections['default'].queries[-1]

By removing slicing, you can print all queries executed, as explained in Django documentation:

from django.db import connection; print connection.queries # print all queries executed

Today I’ll represent one of my favorite dishes cardiovascular omelet a.k.a. Heartbreak Kid. Originally this recipe is presented at www.kaenkky.com.

First we need functional specs – dish must contain lot of fat, salt, chili and taste good. Ok, that’s all for specs.

Technical specs:

• At least 5 eggs
• Packet of bacon (around 150g)
• Micropizza (salami, ham, meat. pick your favorite)
• Black pepper
• Salt
• Tabasco
• Oil
• Smetana or in case of emergency crème fraîche
• Hot chili if you like

Implementation details:

Now it helps if you have two pans, heat them both and apply a bit of oil.

First we start preparing omelet. Take a bowl and beat eggs. Beat them good. It helps relieving stress that programming causes.

Start frying bacon on a one pan and put half of eggs on a second pan. When bacon is ready and first omelet is ready put bacon on top of first omelet. Add rest of eggs on free pan.

Top bacon with chili, Smetana, black pepper etc. Whatever you happen to like.

Heat micropizza in a micro. put it upside down on top of first omelet and heat so pizza melts together with omelet.

When second omelet is almost ready, flip it over on top of first omelet.

Carefully move to plate and enjoy.

And to scare you all some approximate nutrition facts:

I’ll add pics later.

To make things easy Let’s start by copying and modifying existing decorators from Django sources (note that these don’t work with Django 1.2):

from django.http import HttpResponseRedirect, HttpResponse
from django.utils.http import urlquote
from django.utils.functional import wraps
from django.utils.decorators import auto_adapt_to_methods
from django.contrib.auth import REDIRECT_FIELD_NAME

def user_passes_test_with_ajax(test_func, login_url=None, redirect_field_name=REDIRECT_FIELD_NAME):
    """
    Decorator for views that checks that the user passes the given test,
    redirecting to the log-in page if necessary. The test should be a callable
    that takes the user object and returns True if the user passes.

    Returns special response to ajax calls instead of blind redirecting.
    """
    if not login_url:
        from django.conf import settings
        login_url = settings.LOGIN_URL

    def decorator(view_func):
        def _wrapped_view(request, *args, **kwargs):
            if test_func(request.user):
                return view_func(request, *args, **kwargs)
            path = urlquote(request.get_full_path())
            tup = login_url, redirect_field_name, path
            # Hook in ajax
            if not request.is_ajax():
                return HttpResponseRedirect('%s?%s=%s' % tup)
            else:
                # In case of ajax we send 401 - unauthorized HTTP response
                return HttpResponse('%s?%s=%s' % tup, status=401)

        return wraps(view_func)(_wrapped_view)
    return auto_adapt_to_methods(decorator)

def login_required_with_ajax(function=None, redirect_field_name=REDIRECT_FIELD_NAME):
    """
    Decorator for views that checks that the user is logged in, redirecting
    to the log-in page if necessary.

    Takes account ajax handling with redirections
    """
    actual_decorator = user_passes_test_with_ajax(
        lambda u: u.is_authenticated(),
        redirect_field_name=redirect_field_name
    )
    if function:
        return actual_decorator(function)
    return actual_decorator

Then in a view code you just need to use our magical decorator:

from decorators import login_required_with_ajax
from django.http import HttpResponse

@login_required_with_ajax
def test(request):
    return HttpResponse("Success!")

And for the last thing we need hookup in JavaScript. I made example with jQuery:

<DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
		<title>AJAX authentication test</title>
		<script type="text/<span class="><!--mce:0--></script>
		<script type="text/javascript">
			function test_ajax() {
				$.ajax({
					url : '/testview/',
					success : function (data, textStatus, request) {
						$('#_result').html(data);
					},
					error: function(request, textStatus, errorThrown){
						if (request.status == 401) {
							// Redirect to login
							window.location = request.responseText;
						}
					}
				});
			}
		</script>
	</head>
	<body>
		<button type="button" onclick="test_ajax()">Test Ajax</button>
		<div>Result was:<span id="_result">[Not tested yet]</span></div>
	</body>
</html>

There is ticket and patch in Django Trac, but meanwhile I created my own mixin that can be used in deletes:

from django.db.models import OneToOneField, ObjectDoesNotExist
from django.utils.encoding import StrAndUnicode
from django.utils.translation import ugettext as _

class ForeignKeysExist(StrAndUnicode, Exception):
    def __init__(self, parent, child, field):
        '''
            Arguments:
            parent - parent instance (that contains child records)
            child  - object that have foreign key pointing to the parent instance
            field  - child instance foreign key field name
        '''
        self.parent = parent #parent instance
        self.child = child #child that has reference to this parent
        self.field = field #field in the child class that points to the parent
        self.msg =  _('Child record %s.%s exists for %s') % (_(child), _(field), _(parent))

        super(ForeignKeysExist, self).__init__(self.msg)

    def __unicode__(self):
        return self.msg

class NoDeleteCascadeMixin(object):
    """
    Mixin to prevent deletion of model
    if there exists any children
    """

    def delete(self):
        # Copied sanity test from django.db.models.ModelBase.delete
        assert self._get_pk_val() is not None, "%s object can't be deleted because its %s attribute is set to None." % (self._meta.object_name, self._meta.pk.attname)

        opts = self._meta

        for related in opts.get_all_related_objects():
            rel_accessor = related.get_accessor_name()
            if isinstance(related, OneToOneField):
                try:
                    o = getattr(self, rel_accessor)
                except ObjectDoesNotExist:
                    pass # No item in one to one
                else:
                    raise ForeignKeysExist(related.parent_model._meta.object_name, opts.object_name, related.field.name)
            else:
                rel_manager = getattr(self, rel_accessor)
                if rel_manager.count():
                    raise ForeignKeysExist(related.parent_model._meta.object_name, related.model._meta.object_name, related.field.name)

        super(NoDeleteCascadeMixin, self).delete()

And usage is simple, just put NoDeleteCascadeMixin to your model as a first one.

class MyModel(NoDeleteCascadeMixin, models.Model):
    # Fields here

First thing is to download and install Python. I suggest using latest stable version. You can find downloads at http://www.python.org/download/

I assume that you used standard c:\python26 as installation path from now on.

First, you need to add c:\python26\ and c:\python26\scripts\ to your path settings. Right click on Computer, select Properties. Select Advanced settings and then Advanced settings and click on Environment Variables. Depending on a case you add them to user (for you only) or to system (for all). If PATH variable exists, add those two mentioned paths to there, otherwise you need to create new variable named PATH. After adding and applying settings open new cmd console and check that path really has those newly added directories by typing SET PATH if you get paths listed you’re good to go. Note that setting environment varies a bit between different Windows versions.

Next you must install setuptools (a.k.a. easy_install) http://pypi.python.org/pypi/setuptools.

Now you can install Django very easily. Just type easy_install django and you get latest stable Django in no time installed.

Now, create first project somewhere in your development directories: django-admin.py startproject mytestproject

Go in newly created testproject directory, run manage.py runserver  and point your browser to http://localhost:8000/ You should see Django welcome screen.

If you encounter any errors, revise that you did all necessary steps.

So, not much to say, here’s the code itself.

from django.db import transaction
from django.utils.encoding import force_unicode
from django.utils import datetime_safe
from django.utils.functional import Promise
import django.utils.simplejson as json
import datetime

class rpcmethod(object):
    def __init__(self, method):
        self.method = method

    def __call__(self, *args, **kwargs):
        return self.method(*args, **kwargs)

    def get_args(self, omittable=lambda m : m in ('self', 'request',)):
        from inspect import getargspec
        return [ a for a in getargspec(self.method).args if not omittable(a) ]

class NoSuchMethod(Exception):
    pass

class JsonRpc(object):
    """
    JSON-RPC handler class for a view.

    Usage:

    def myview(request):
        rpc = JsonRpc( MyRpcClass() )
        result = rpc.handle_request(request)
        return HttpResponse(result)

    class MyRpcClass(object):
        url = reverse(myview)

        @rpcmethod
        def add(self, x, y):
            return x + y

    """

    def __init__(self, instance, allow_errors=True, report_methods=True):
        self.instance = instance
        self.allow_errors = allow_errors
        self.report_methods = report_methods

        if not hasattr(self.instance, "url"):
            raise Exception("'url' not present in supplied instance")

    def get_public_methods(self):
        return [
            m for m in dir(self.instance) if getattr(self.instance, m).__class__ is rpcmethod
        ]

    def generate_smd(self):
        smd = {
                "serviceType": "JSON-RPC",
                "serviceURL": self.instance.url,
                "methods": []
        }

        if self.report_methods:
            smd["methods"] = [
                {"name": method, "parameters": getattr(self.instance, method).get_args()} \
                for method in self.get_public_methods()
            ]

        return json.dumps(smd)

    def dispatch(self, method, params):
        if method in self.get_public_methods():
            return getattr(self.instance, method)(self.instance, *params)
        else:
            raise NoSuchMethod(method)

    def serialize(self, request):
        raw_request = json.loads(request.raw_post_data)
        request_id = raw_request.get("id", 0)
        request_method = raw_request.get("method")
        request_params = raw_request.get("params", [])

        response = {"id": request_id}

        try:
            response["result"] = self.dispatch(request_method, request_params)
        except Exception:
            # Fatal error
            if self.allow_errors:
                from traceback import format_exc
                response["error"] = {
                        'type' : 'error',
                        'message' : "%s" % format_exc(),
                }
            else:
                response["error"] = {
                        'type' : 'error',
                        'message': 'error',
                }

        # Rollback after failure
        if transaction.is_dirty():
            transaction.rollback()

        return json.dumps(response, cls=AugmentedJSONEncoder)

    def handle_request(self, request):
        if request.method == "POST" and len(request.POST) > 0:
            return self.serialize(request)
        else:
            return self.generate_smd()

class AugmentedJSONEncoder(json.JSONEncoder):
    """
    Augmentation for simplejson encoder.
    Now additionally encodes arbitrary iterables, class instances, decimals,
    lazy translations, dates, times and datetimes.
    """

    DATE_FORMAT = "%Y-%m-%d"
    TIME_FORMAT = "%H:%M:%S"

    def default(self, o):
        if(hasattr(o, "__iter__")):
            iterable = iter(o)
            return list(iterable)
        elif(hasattr(o, "__add__") and hasattr(o, "__sub__") and hasattr(o, "__mul__")):
            return float(o)
        elif isinstance(o, datetime.datetime):
            d = datetime_safe.new_datetime(o)
            return d.isoformat()
        elif isinstance(o, datetime.date):
            d = datetime_safe.new_date(o)
            return d.strftime(self.DATE_FORMAT)
        elif isinstance(o, datetime.time):
            return o.strftime(self.TIME_FORMAT)
        elif isinstance(o, Promise):
            return force_unicode(o)
        elif(hasattr(o, "__class__")):
            return o.__dict__
        else:
            return str(o)

On of the first questions might be, how to pass request object to my rpc method? Answer is simple – since your rpc class can have any kind of init with any kind of parameters, it’s more than natural to add request as one of the init parameters and add it to instance.

def myview(request):
    rpc = JsonRpc( MyRpcClass(request) )
    result = rpc.handle_request(request)
    return HttpResponse(result)

 class MyRpcClass(object):
    url = reverse(myview)

    def __init__(self, request):
        self.request = request

    @rpcmethod
    def add(self, x, y):
        # Here you now have access to self.request
        return x + y

I had a need of such system when creating application that was serves multiple customers. Each customer shares some common data between each other and then some of their own. To resolve my problem I loaned a piece from Django django.contrib.auth models and modified it a bit.

So define your model like this:

from django.db import models

class MyExtensionNotAvailable(Exception):
    pass

class MyModel(models.Model):
# your common fields comes here

@property
def extension(self):
"""
Returns extension for this models. Raises
        MyExtensionNotAvailable if no extensions allowed.
        """
        if not hasattr(self, '_ext_cache'):
            from django.conf import settings
            if not getattr(settings, 'MYMODEL_EXTENSION_MODEL'):
                raise MyExtensionNotAvailable
            try:
                app_label, model_name = settings. MYMODEL_EXTENSION_MODEL.split('.')
                model = models.get_model(app_label, model_name)
                self._ext_cache = model._default_manager.using(self._state.db).get(mymodel__id__exact=self.id)
                self._ext_cache.mymodel = self
            except (ImportError, ImproperlyConfigured):
                raise MyExtensionNotAvailable
        return self._ext_cache

Since extension is not created automatically when accessing extension creation must happen somehow. And here is where signals are very useful.

Add following code at the end of models.py. In real case you usually separate signal handling module. There you just make sure that you import your models inside handlers, otherwise you make circular imports and that’s something Python is not happy about.

def post_mymodel_create(sender, **kwargs):
    if kwargs['created']:
        #from models import MyModelExtension
        MyModelExtension(mymodel=kwargs['instance']).save()

# Connect signal
django.db.signals.post_save.connect(post_mymodel_create, sender=MyModel)

Why signal? Because MyModel doesn’t have any more knowledge about your MyModelExtension than it has a field named “mymodel”. Rest is like a black box. That’s why you have to use signal. Signal handler knows all about your model and can populate all required fields with proper data.

To use extension is really simple, just create extension model, add field named “mymodel” to have foreign key (unique one) to MyModel. Then just point in settings MYMODEL_EXTENSION_MODEL parameter to your extension model and things get running:

class MyModelExtension(models.Model):
    mymodel = models.ForeignKey(MyModel, unique=True)

    # Your fields here

And in settings.py you have to tell which model is your extension model: MYMODEL_EXTENSION_MODEL = ‘myapp.MyModelExtension’.

My original model was like:

class LookupTable(models.Model):
    groupname = models.CharField(max_length=64)
    key = models.CharField(max_length=64)
    value = models.CharField(max_length=512)

I had dozens of models pointing to this single lookup table which was nightmare, specially with reverse relations. But I managed to figure one solution for this situation.

I used a custom save code, a custom manager and a magical proxy functionality in the Django. Let the code to speak for itself.

So here is my magical GenericLookupManager

class GenericLookupManager(models.Manager):
    def get_query_set(self):
        qs = super(GenericLookupManager, self).get_query_set()
        try:
            return qs.filter(groupname=self.model.GROUPNAME)
        except (ValueError, AttributeError):
            return qs
        return None

Enhanced LookupTable model

class LookupTable(models.Model):
    groupname = models.CharField(max_length=64)
    key = models.CharField(max_length=64)
    value = models.CharField(max_length=512)

    objects = GenericLookupManager()

    def save(self, *args, **kwargs):
        try:
            self.groupname = self.GROUPNAME
        except (ValueError, AttributeError):
            pass # No GROUPNAME, pass

        super(LookupTable, self).save(*args, **kwargs)

And finally, how to use that model with proxying

class UserType(LookupTable):
    GROUPNAME = 'USER_TYPE'

    class Meta:
        proxy = True

Now you can use proxied model to save, load and query it. Overridden LookupTable manager and save takes care that groupname is always taken into account.