What you need to do, instead of just making two fields, is to create one field and use a widget which renders two input boxes, so that all the work is done behind the stages.

import django.newforms as forms
from django.utils.translation import ugettext_lazy as _

class DualPasswordWidget(forms.Widget):
    pass0_field = '%s_pass0'
    pass1_field = '%s_pass1'

    def __init__(self, *args, **kwargs):
        super(DualPasswordWidget, self).__init__(*args, **kwargs)

    def render(self, name, value, *args, **kwargs):
        out = ( forms.PasswordInput().render(self.pass0_field % name, None),
                forms.PasswordInput().render(self.pass1_field % name, None) )
        return '<br />'.join(out)

    def value_from_datadict(self, data, files, name):
        pass0 = data.get(self.pass0_field % name, None)
        pass1 = data.get(self.pass1_field % name, None)
        if pass0 and pass1:
            return (pass0, pass1)
        return None

class DualPasswordField(forms.Field):
    """
    Field used to prevent password typos by asking the same password twice
    and checking if it's the same
    """
    widget = DualPasswordWidget()
    def __init__(self, *args, **kwargs):
        kwargs.setdefault('help_text', _('Insert your password twice.'))
        super(DualPasswordField, self).__init__(*args, **kwargs)

    def clean(self, value):
        super(DualPasswordField, self).clean(value)
        if value:
            pass0, pass1 = value
            if pass0 == pass1:
                return pass0
            raise forms.ValidationError(_('Password Missmatch.'))

class NewUserForm(forms.Form):
    username = forms.CharField(label=_('username'))
    password = DualPasswordField(label=_(u"password"))
    email   = forms.EmailField(label=_('email')

So there I was, i took recaptcha-client (MIT/X11) from Ben Maurer and modified it a little bit, so that it has support for unicode user input and make it able to handle some more configuration when displaying the captcha.

So, you want to use reCAPTCHA in you new shinny Python web app. All you have to do is put librecaptcha.py somewhere in your PYTHONPATH and use it like this:

First we need some configuration.

>>> import librecaptcha

# set our public and private keys
# you can get them at: https://admin.recaptcha.net/recaptcha/createsite/
>>> RECAPTCHA_PUB_KEY = '79ehj2hd09wjd90jwqoierhde7892ehqd89whdwq'
>>> RECAPTCHA_PRIV_KEY = '0nm29ue03ud09j3mu0e93209eu2109ue09dwuqeq'

>>> html_for_captcha = librecaptcha.displayhtml(RECAPTCHA_PUB_KEY)
>>> print html_for_captcha
<script type="text/javascript">
  var RecaptchaOptions={theme:'red', lang:'en', tabindex:'0',
                        custom_theme_widget:'null'};
</script>
<script type="text/javascript" src="http://api.recaptcha.net/challenge?k=79ehj2hd09wjd90jwqoierhde7892ehqd89whdwq"></script>
<noscript>
  <div>
    <object data="http://api.recaptcha.net/noscript?k=79ehj2hd09wjd90jwqoierhde7892ehqd89whdwq" type="text/html" height="300" width="500"></object>
  </div>
  <p><textarea name="recaptcha_challenge_field" rows="3" cols="40"></textarea></p>
  <p><input type='hidden' name='recaptcha_response_field' value='manual_challenge' /></p>
</noscript>

>>> html_for_captcha = librecaptcha.displayhtml(RECAPTCHA_PUB_KEY, lang='es', theme='white')
>>> print html_for_captcha
<script type="text/javascript">
  var RecaptchaOptions={theme:'white', lang:'es', tabindex:'0',
                        custom_theme_widget:'null'};
</script>
<script type="text/javascript" src="http://api.recaptcha.net/challenge?k=79ehj2hd09wjd90jwqoierhde7892ehqd89whdwq"></script>
<noscript>
  <div>
    <object data="http://api.recaptcha.net/noscript?k=79ehj2hd09wjd90jwqoierhde7892ehqd89whdwq" type="text/html" height="300" width="500"></object>
  </div>
  <p><textarea name="recaptcha_challenge_field" rows="3" cols="40"></textarea></p>
  <p><input type='hidden' name='recaptcha_response_field' value='manual_challenge' /></p>
</noscript>

# when the user submits the form, you need to get 3 values from that request.
# 1. REMOTE_ADDR
# 2. from request's POST: recaptcha_challenge_field
# 3. from request's POST: recaptcha_response_field
# note the way you access to theese values varies depending on your web framework
# and then:
>>> remote_ip = request.META['REMOTE_ADDR']
>>> challenge = request.POST['recaptcha_challenge_field']
>>> responese = request.POST['recaptcha_response_field']
>>> recaptcha_response = librecaptcha.submit(challenge, response, RECAPTCHA_PRIV_KEY, remote_ip)

# if everything went ok, recaptcha_response.is_valid should be true
# and recaptcha_response.error_code should be None
# example: valid reCAPTCHA
>>> recaptcha_response.is_valid
True
>>> recaptcha_response.error_code
None

# else, if something went wrong, recaptcha_responser.is_valid will be False
# and recaptcha_response.error_code will be some of this codes:
# http://recaptcha.net/apidocs/captcha/
# example: invalid reCAPTCHA
>>> recaptcha_response.is_valid
False
>>> recaptcha_response.error_code
'incorrect-captcha-sol'

• Now it uses librecaptcha.py.
• Automagically generates the captcha field instead of having to define it when you create your form.
• Appearance customization is now possible via settings.py.
• By default, if settings.DEBUG is set to True, reCAPTCHA will always be valid. (It’s annoying to fill forms when developing).
• Localized error messages are shown when (if anyone).

So to use it, we will be using the same approach proposed by SmileyChris, the file recaptcha_newforms.py provides a form which you should inherit from, and pass the remote ip address to it’s constructor.

So, take this as an example:

from django.shortcuts import render_to_response
import django.newforms as forms
from recaptcha_newforms import RecaptchaForm

# create our form inheriting from RecaptchaForm
class NewAnimalForm(RecaptchaForm):
    name = forms.CharField(label='animal name')
    legs = forms.IntegerField(label='number of legs')

# and the view would be... just a little different.
# when the form is created, we explicitly pass the remote_ip
# to the form constructor. And that's all the magic.
def new_animal(request):
    remote_ip = request.META['REMOTE_ADDR']
    if request.method == 'POST':
        form = NewAnimal(remote_ip, request.POST)
        if form.is_valid():
            # if we get here, the captcha solution the user provided
            # was ok, so do whatever you want to do with your data here.
            # ...
    else:
        form = NewAnimalForm(remote_ip)

    return render_to_response('animals/new_animal.html', {'form': form })

# your project's settings.py
RECAPTCHA_PUB_KEY = '6dihaiodhoiwahdiowahoidwaoihdoiwahS'
RECAPTCHA_PRIV_KEY = '6Lfdwanoidhwaoidhoiwahdoiwahoiddsp'
RECAPTCHA_THEME = 'white' #optional
# lang value is taken from LANGUAGE_CODE, example
LANGUAGE_CODE = 'es_ar'
# will render the captcha in spanish (es)

NOTE: Added support for the autoescaping implemented in revision 6671.

First, I shall give you an introduction to what free (as in freedom) software is. When we talk about free software, we are referring to software which you are permitted to use, modify, remix, redistribute, enhance, and even sell copies of it. All that, as long as you ensure end-users (you, world) have the same rights the very first authors (you? world?) have, giving them access to all those features. How do we achieve that? Licenses have been developed for use in software, information and media projects which give us the possibility to get and provide the benefits of freedom. There’s one out there, the one, which is like the queen of licenses, it’s the famous GNU GPL, or just GPL (mainly versions 2 and 3), which provide freedom to most of the software out there.

And talking about software, we need a base where to use it. Today is your lucky day! Guess what? Although this might seem a bad world we live in, sometimes, we just have to open our eyes to make it a better place. Today, we have our base (one of many out there), which happens to be an operating system licensed under the terms of the GPLv2, thus giving us the freedom we need. It’s ready for your desktop, production or entertainment computer, and has a pretty penguin as it’s pet.

I’m talking about Linux, which is no more no less, the result of millions of developers, designers, coders and thinkers (¿?) out there, which proudly can choose and say one of these:

• All your base are belong to us.
• All your base are belong to you.
• All our base are belong to us.
• All our base are belong to you.
• …and so on.

Because that’s what free software is about, and that’s about what this blog will be (mainly) about: Linux, Software, Development, Knowledge, Magic, Love and Freedom.

So, please wear your seatbelts and enjoy the ride. Thanks for reading.