[1.9.x] Removed British/Austrialian word: whilist.

    def cycle_key(self):

        """

        Creates a new session key, whilst retaining the current session data.

        Creates a new session key, while retaining the current session data.

        """

        data = self._session_cache

        key = self.session_key

    The parameters are callables to compute the ETag and last modified time for

    the requested resource, respectively. The callables are passed the same

    parameters as the view itself. The Etag function should return a string (or

    None if the resource doesn't exist), whilst the last_modified function

    None if the resource doesn't exist), while the last_modified function

    should return a datetime object (or None if the resource doesn't exist).

    If both parameters are provided, all the preconditions must be met before

    def get_absolute_url(self):

        return "/people/%i/" % self.id

(Whilst this code is correct and simple, it may not be the most portable way to

While this code is correct and simple, it may not be the most portable way to

write this kind of method. The :func:`~django.core.urlresolvers.reverse`

function is usually the best approach.)

function is usually the best approach.

For example::

    As part of working out which URL names map to which patterns, the

    ``reverse()`` function has to import all of your URLconf files and examine

    the name of each view. This involves importing each view function. If

    there are *any* errors whilst importing any of your view functions, it

    there are *any* errors while importing any of your view functions, it

    will cause ``reverse()`` to raise an error, even if that view function is

    not the one you are trying to reverse.

You may notice that Django already provides simple and straightforward

conditional ``GET`` handling via the

:class:`django.middleware.http.ConditionalGetMiddleware` and

:class:`~django.middleware.common.CommonMiddleware`. Whilst certainly being

:class:`~django.middleware.common.CommonMiddleware`. While certainly being

easy to use and suitable for many situations, those pieces of middleware

functionality have limitations for advanced usage: