Debugging email on Django application development

One of the common functionalities in Django applications is to send emails, such as for user password resets.

Python SMTP

Since Python comes with it’s own SMTP, it’s easy to redirect the emails from the local Django application being developed to this dummy mail server and see the emails on the console.
Here’s how to do it:

  • Run Python SMTP with this command line:
    python -m smtpd -n -c DebuggingServer localhost:1025
  • Define Django email server as:
    EMAIL_HOST = 'localhost'
    EMAIL_PORT = 1025

And that’s it. All emails sent will be seen on the console where you’r running the Python SMTP.
This technique is actually quite useful since you can use this for any application you are developing locally.

Redirect to Console

There’s another way to see the emails on the console with no dependencies.
To do so, just configure the email to use the console email backend.

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

This will actually redirect all emails to the standard output, which usually is the console.

Redirect to File

Another approach is to redirect the emails into a local file for prior usage.
To do so, just configure the email to use the file email backend.

EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend'
EMAIL_FILE_PATH = '/tmp/app-messages' # change this to a proper location

This will write all emails into separate files located in


and you can analyze them latter.

Step-byStep Tuturial of Ajax in Django Using dajaxice

Using Ajax in Django applications is quite easy when using dajaxproject, Dajax and Dajaxice.
I assume you have pip installed on your system, if that’s not the case, install it.

The first step is to download and install Dajax core:

pip install -e git://

Copy your flavoured prototype function.

Download and install Dajaxice:

pip install -e git://

In the application where the Ajax funtionality is required, create an “” file with the required Ajax functions.
In the example below it will load cities from a selected country, a tipical problem of master-detail chained selects.

from dajax.core import Dajax
from dajaxice.decorators import dajaxice_register
from my_app.models import City

def updateCity(request, option):
    dajax = Dajax()
    options = City.objects.filter(
    out = ""
    for o in options[int(option)]:
        out += "%s%s" % (out,o,)

    return dajax.json()

The Ajax function is a simple function that must be registered with the @dajaxice_register anotation.
It gets the cities from a specific country and assigns those values to the innerHTML of the id_city HTML object.

In the forms, the country must call the “updateCity” Ajax funtion to load the cities on the select country.

# Address
class AddressForm(forms.Form):
Address form


    country = forms.ModelChoiceField(widget = forms.Select(attrs = {'onchange' : "Dajaxice.acg.updateCity(Dajax.process,{'option':this.value});"}), queryset=Country.objects.all(), required=True,  empty_label = lcountry_empty, label=lcountry, help_text = lcountry_help, error_messages={'required': lcountry_required})
    city = forms.ModelChoiceField(queryset=City.objects.all(), required=False, empty_label = lcity_empty, label=lcity, help_text = lcity_help)
    address = forms.CharField(widget=forms.Textarea(attrs={'cols': 20, 'rows': 3}), min_length=10, max_length=50, label='Address')
    zip = forms.CharField(max_length=60, required=True, label='Zip code' )

The only change here, regarding to a common form definition, is to inject the call of the Ajax “updateCity” function on the “onChange” event. Note that the city must be called “city” in order to bind with the HTML id_city object (remember, Django gives “id_” to the id)

Finally, your HTML file must include the jquery.dajax.core.js file in the HEAD section. Copy it to someplace where the browser will be able to load it, like

<script src="/media/dajax/jquery.dajax.core.js" type="text/javascript" charset="utf-8"></script>

And this is all one requires to do in order to have Ajax working on a Django application.

Painless Django with MySQL Install

When using Django for developing a web applications, it’s common to use MySQL as a data repository.
In order to use this combination of technolgies, one needs to setup all the different pieces. Setting up all this may not be as easy as it may seem and it actually will take a bit longer than one may expect.
To ease this process, here’s a simple step-by-step guide to help seting a Django with MySQL development environment.

The first step is to download and install Python. Current Django version, 1.3, does not work on Python 3, so download the latest Python 2 version, presently 2.7.2, or use your system package manager to get it from the official repository.

The second step is to download and install MySQL.
Check your system package manager to get it from the official repository, if available.
Don’t try to use Xampp. It may work but you’ll have to hack some installation procedures, specially in Windows 64 bit. For instance, the database connector will look up  the MySQL location in the Windows registry and it will be missing.
I recommend the MySQL bundle, since it will come with useful software for database management.

The third step is to download and install Python setuptools.
If you’re using Windows 64 bits, and you’re getting a “Python not found on Registry” error, you may use this workaround.

Finally, we need to download the MySQL-Python connector so that we can use MySQL from Python.
Uncompress the file and, on a shell, perform the standard installation procedure: python install. Depending on your system, you may need to run this with administration privilidges.
If you’re using Windows, I seriously recommend that you download and install codegood build. If you don’t wish to use codegood build and are getting file not found errors originated from a registry key not found – usually in 64 bit versions – just edit the site.cfg file with a plain text editor and change the registry_key to “SOFTWARE\Wow6432Node\MySQL AB\MySQL Server 5.5“, in 64 bit, taking in consideration that the version numbers should correspond to your MySQL installed version. When in doubt, use Windows Registry application, regedit.exe, to check the correct registry key.

Optionally, if you’re installing on Windows, I recommend you to install MSYS and to run the Django commands from this shell.
This will enable you a linux like shell that is helpful to process some commands like localization, e. g. the gettext tool. If you don’t wish to install MSYS, check the Django documentation on how to get the required tools to work on Windows.

Since all the technologies are always under development, make sure you get the right versions of each so that things work properly.

After following these steps, Python should connect to MySQL, and so should Django.