Merge remote-tracking branch 'core/master' into schema-alteration

SESSION_EXPIRE_AT_BROWSER_CLOSE = False                 # Whether a user's session cookie expires when the Web browser is closed.

SESSION_ENGINE = 'django.contrib.sessions.backends.db'  # The module to store session data

SESSION_FILE_PATH = None                                # Directory to store session files if using the file session module. If None, the backend will use a sensible default.

SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer'  # class to serialize session data

#########

# CACHE #

        validator.validate(cls, model)

    def __init__(self):

        self._orig_formfield_overrides = self.formfield_overrides

        overrides = FORMFIELD_FOR_DBFIELD_DEFAULTS.copy()

        overrides.update(self.formfield_overrides)

        self.formfield_overrides = overrides

        # If the field specifies choices, we don't need to look for special

        # admin widgets - we just need to use a select widget of some kind.

        if db_field.choices:

            # see #19303 for an explanation of self._orig_formfield_overrides

            if db_field.__class__ in self._orig_formfield_overrides:

                kwargs = dict(self._orig_formfield_overrides[db_field.__class__], **kwargs)

            return self.formfield_for_choice_field(db_field, request, **kwargs)

        # ForeignKey or ManyToManyFields

    ORDER_VAR, PAGE_VAR, SEARCH_VAR)

from django.contrib.admin.templatetags.admin_static import static

from django.core.exceptions import ObjectDoesNotExist

from django.core.urlresolvers import NoReverseMatch

from django.db import models

from django.utils import formats

from django.utils.html import escapejs, format_html

        row_class = mark_safe(' class="%s"' % ' '.join(row_classes))

        # If list_display_links not defined, add the link tag to the first field

        if (first and not cl.list_display_links) or field_name in cl.list_display_links:

            table_tag = {True:'th', False:'td'}[first]

            table_tag = 'th' if first else 'td'

            first = False

            # Display link to the result's change_view if the url exists, else

            # display just the result's representation.

            try:

                url = cl.url_for_result(result)

            except NoReverseMatch:

                link_or_text = result_repr

            else:

                url = add_preserved_filters({'preserved_filters': cl.preserved_filters, 'opts': cl.opts}, url)

                # Convert the pk to something that can be used in Javascript.

                # Problem cases are long ints (23L) and non-ASCII strings.

                    attr = pk

                value = result.serializable_value(attr)

                result_id = escapejs(value)

            yield format_html('<{0}{1}><a href="{2}"{3}>{4}</a></{5}>',

                              table_tag,

                              row_class,

                link_or_text = format_html(

                    '<a href="{0}"{1}>{2}</a>',

                    url,

                    format_html(' onclick="opener.dismissRelatedLookupPopup(window, '{0}'); return false;"', result_id)

                        if cl.is_popup else '',

                              result_repr,

                    result_repr)

            yield format_html('<{0}{1}>{2}</{3}>',

                              table_tag,

                              row_class,

                              link_or_text,

                              table_tag)

        else:

            # By default the fields come from ModelAdmin.list_editable, but if we pull

import json

from django.contrib.messages.storage.base import BaseStorage

from django.contrib.messages.storage.cookie import MessageEncoder, MessageDecoder

from django.utils import six

class SessionStorage(BaseStorage):

        always stores everything it is given, so return True for the

        all_retrieved flag.

        """

        return self.request.session.get(self.session_key), True

        return self.deserialize_messages(self.request.session.get(self.session_key)), True

    def _store(self, messages, response, *args, **kwargs):

        """

        Stores a list of messages to the request's session.

        """

        if messages:

            self.request.session[self.session_key] = messages

            self.request.session[self.session_key] = self.serialize_messages(messages)

        else:

            self.request.session.pop(self.session_key, None)

        return []

    def serialize_messages(self, messages):

        encoder = MessageEncoder(separators=(',', ':'))

        return encoder.encode(messages)

    def deserialize_messages(self, data):

        if data and isinstance(data, six.string_types):

            return json.loads(data, cls=MessageDecoder)

        return data

            MESSAGE_TAGS    = '',

            MESSAGE_STORAGE = '%s.%s' % (self.storage_class.__module__,

                                         self.storage_class.__name__),

            SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer',

        )

        self.settings_override.enable()