It is actually pretty simple, in your form you add a custom __init__ function that sets the request as a parameter:

class PasswordRecoverForm(PasswordResetForm):
    def __init__(self, *args, **kwargs):
    self.request = kwargs.pop('request', None)
    super(PasswordRecoverForm, self).__init__(*args, **kwargs)

def clean_email(self):
    """Do something with the request"""
    print self.request

Then in your view code you can pass the request as a parameter.

form = PasswordRecoverForm(request=request)

from django.contrib.auth.models import User
User._meta.ordering = ['-email']

or

from django.contrib.auth.models import Group
Group._meta.ordering = ['-id']

There is a simple way to change the max length attribute:

from django.contrib.auth.models import User
User._meta.get_field_by_name('username')[0].max_length=75

I first created a file called decorators.py and placed it in the project folder.

from django.core.urlresolvers import reverse
from django.http import HttpResponse, HttpResponseRedirect

from functools import wraps

def access_required(permission):
    def decorator(func):
        def inner_decorator(request, *args, **kwargs):
            if permission == 'admin':
                if request.session['user_profile'].is_account_admin == 1:
                    return func(request, *args, **kwargs)
                else:
                    return HttpResponseRedirect(reverse('dashboard'))

        return wraps(func)(inner_decorator)

    return decorator

Then in my views I simply imported the decorator and added it to my view:

from webapp.decorators import access_required
@access_required('admin')
    def account_users(request):
        ...

# Import server specific settings
try:
    from settings_local import *
except ImportError:
    pass

Then put any local development settings in a file called settings_local.py and you can override anything from settings.py.
If settings_local.py does not exist on your production server no error is thrown.

The way we do this is to write a simple custom auth backend in the following way:

1. In settings.py add the following lines (replace yourprojectname with the name of your app):

AUTHENTICATION_BACKENDS = (
    'yourprojectname.backends.EmailAuthBackEnd',
    'django.contrib.auth.backends.ModelBackend',
)

2. Create a file called backends.py and put it in your root folder (i.e. the same folder as settings.py)

from django.contrib.auth.backends import ModelBackend
from django.contrib.admin.models import User

class EmailAuthBackEnd(ModelBackend):
    def authenticate(self, email=None, password=None,**kwargs):
        try:
            user = User.objects.get(email=email)  

            if user.check_password(password):
                return user
            return None
        except User.DoesNotExist:
            return None

3. In your views import the authenticate back end and then call the authenticate function:

from django.contrib.auth import authenticate
....
user = authenticate(email=email, password=password)

At present there is no easy way to format the date but the following example of one method of how to do it:

class News(models.Model):
    headline = models.CharField(max_length=100)
    date = models.DateTimeField()
    article = models.TextField()
    published = models.BooleanField()

class NewsAdmin(admin.ModelAdmin):
    list_display = ('headline', 'format_date', 'published')

    def format_date(self, obj):
        return obj.date.strftime('%d %b %Y %H:%M')
    format_date.short_description = 'Date'

Here is an example.
You want to limit the author of the news article to only show those users who are in the group admin (which is id: 1). You would use, limit_choices_to={‘groups__in’: [1]}

class News(models.Model):
    headline = models.CharField(max_length=100)
    author = models.ForeignKey('users.UserProfile', limit_choices_to={'groups__in': [1]})
    date = models.DateTimeField()
    article = models.TextField()
    published = models.BooleanField()

Now when you edit a news article only the users who are in the admin group will be shown.

You can also use a Q object instead of a dictionary, which I will cover in another article.