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.

Django wysiwyg Editor

Many Django projects require a wysiwyg editor. To cover this, there is an application for making Django textareas rich text editors: django-wysiwyg.

To use it, start by installing it through

pip install django-wysiwyg

Then, on your HTML template, include application:

{% load wysiwyg %}

As an example, take the following form:

# Event Edit From
class EventsDataForm(forms.Form):
        Event data form

    min_description_chars = 10
    max_description_chars = 2000

    ltitle = ugettext("Title")    
    ltitle_help = ugettext("The title of the event.")
    ltitle_required = ugettext("Please enter the title.")
    ldescription = ugettext("Description")
    ldescription_help = ugettext("Enter the event description.")
    ldescription_required = ugettext("Please describe the event.")    
    ldescription_min_length = ugettext('The minimum length is %s characters.')%(min_description_chars)
    ldescription_max_length = ugettext('The maximum length is %s characters of plain text (less characters for formated text)')%(max_description_chars)

    id = forms.IntegerField(widget=forms.HiddenInput(), required=False)
    title = forms.CharField(max_length=60, required=True, label=ltitle, help_text=ltitle_help, error_messages={'required': ltitle_required})
    long_description = forms.CharField(widget=forms.Textarea(attrs={'cols': 50, 'rows': 5}), min_length=min_description_chars, max_length=max_description_chars, required=True, label=ldescription, help_text=ldescription_help)

The “long_description” field is the field that will be wysiwyg editor.

Then, on your form, setup up the wysiwyg, draw the form and link it to your form field. Here’s an example:

{% block content %}
<form enctype="multipart/form-data" action='.' method='post'>
  {% csrf_token %}
    {% wysiwyg_setup %}
    {{ form.as_table }}
    {% wysiwyg_editor "id_long_description" %}
  <input type="submit" value="Save" />
{% endblock %}


{% wysiwyg_setup %}

sets up the application.

{{ form.as_table }}

draws the form.

{% wysiwyg_editor "id_long_description" %}

links the form field “long_description” to the wysiwyg via the identifier.
Take special attention to the identifier, it’s the name of the field in the forms and it should be preceded by “id_”.

That is enough to make the “long_description” field a wysiwyg editor.

If one requires customization, for instance change the width or the toolbar buttons, one can do this by customizing the


variable. See the documentation for extra information about how to customize the component.
The trick is to perform the customization on the bottom of the page, just before closing the


First, load the “django_wysiwyg_editor_config” block, then load its code and, finally, apply your customization. Here’s and example:

{% block django_wysiwyg_editor_config %}
{{ block.super }}
django_wysiwyg_editor_config.width = "450px";
django_wysiwyg_editor_config.height = "200px";
{% endblock %}

And that’s it.

jQuery Calendar Date Picker in Django Forms

One of Django missing features that all developers miss is the lack of a calendar component that allows a user to select a date from a visual component instead of writing the date in a text field using a predefined format.

The common solution that seems to use the calendar from the administrator graphical interface.
Unfortunately this is a hack that takes too much work for a possible failure, since a Django update may break it all.

While Django does not provide such component, the best option is to use a solid solution, such as using the independent jQuery Calendar Date Picker.
This can be set up in ten minutes and does not depend on Django version.

The first step is to download the jQuery Datepicker component.

Uncompress it and put it in your media directory, so that it looks something like “media/jquery”, or something else that is fits best with your structure. For the current example “media/jquery” will be used.

In your HTML file, include the following scripts:

<link type="text/css" href="/media/jquery/css/smoothness/jquery-ui-1.8.18.custom.css" rel="Stylesheet" />
<script type="text/javascript" src="/media/jquery/js/jquery-1.7.1.min.js"></script>
<script type="text/javascript" src="/media/jquery/js/jquery-ui-1.8.18.custom.min.js"></script>

Please note that the file names will vary according to the jQuery version and the CSS will vary according with the selected template. Don’t forget to confirm the location and file names.

Next, you must bind your form objects with the jQuery Datepicker with the following script. Also include this on your HTML file

$(function() {
  $( "#id_form_date_field" ).datepicker();

Where “form_date_field” should be your form date field, keep the “#id_” because Django precedes the ids with “id_”

If you require internationalization, load the correspondent i18n file after the “jquery…min.js” file:

<script type="text/javascript" src="/media/jquery/development-bundle/ui/i18n/jquery.ui.datepicker-{{request.LANGUAGE_CODE}}.js"></script>

This will load the appropriate i18n file.

If you try it and it’s not working, check the files location and the name of the object you’re binding to, these are the two most common problems.

Django Inline Forms

In Django sometimes it’s more practical to have a specific HTML inline form than working with the CSS.
Django makes it particular easy. All one has to do is to define an as_inline function that uses <span> instead of <p> or <ul>/<li>.

Here’s a simple example of a form that has a text search and a country drop down list.
Note that the row ender is a combination of three blank spaces. This is obviously practical but not necessarily the best approach.

# Filter country
class FilterCountry(forms.Form):
        Filter country

    lsearch = ugettext("Search")    
    lcountry = ugettext("Only from country")
    lcountry_empty = ugettext('All')
    search_term = forms.CharField(required=False, label=lsearch)
    country = forms.ModelChoiceField(queryset=Country.objects.all(), required=False, empty_label=lcountry_empty, label=lcountry)
    def as_inline(self):
         """Returns this form rendered as HTML inlines."""
         return self._html_output(
                normal_row = u'<span%(html_class_attr)s>%(label)s %(field)s%(help_text)s</span>',
                error_row = u'%s',
                row_ender = ' &nbsp; ',
                help_text_html = u' %s',
                errors_on_separate_row = True)

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.