# Django 1.8.18.dev20170123152445 documentation

# Source code for django.middleware.locale

    "This is the locale selecting middleware that will look at accept headers"

    from django.conf import settings
    from django.core.urlresolvers import (
        LocaleRegexURLResolver, get_resolver, get_script_prefix, is_valid_path,
    )
    from django.http import HttpResponseRedirect
    from django.utils import translation
    from django.utils.cache import patch_vary_headers

    class LocaleMiddleware(object):
        """
        This is a very simple middleware that parses a request
        and decides what translation object to install in the current
        thread context. This allows pages to be dynamically
        translated to the language the user desires (if the language
        is available, of course).
        """
        response_redirect_class = HttpResponseRedirect

        def __init__(self):
            self._is_language_prefix_patterns_used = False
            for url_pattern in get_resolver(None).url_patterns:
                if isinstance(url_pattern, LocaleRegexURLResolver):
                    self._is_language_prefix_patterns_used = True
                    break

        def process_request(self, request):
            check_path = self.is_language_prefix_patterns_used()
            language = translation.get_language_from_request(
                request, check_path=check_path)
            translation.activate(language)
            request.LANGUAGE_CODE = translation.get_language()

        def process_response(self, request, response):
            language = translation.get_language()
            language_from_path = translation.get_language_from_path(request.path_info)
            if (response.status_code == 404 and not language_from_path
                    and self.is_language_prefix_patterns_used()):
                urlconf = getattr(request, 'urlconf', None)
                language_path = '/%s%s' % (language, request.path_info)
                path_valid = is_valid_path(language_path, urlconf)
                if (not path_valid and settings.APPEND_SLASH
                        and not language_path.endswith('/')):
                    path_valid = is_valid_path("%s/" % language_path, urlconf)

                if path_valid:
                    script_prefix = get_script_prefix()
                    language_url = "%s://%s%s" % (
                        request.scheme,
                        request.get_host(),
                        # insert language after the script prefix and before the
                        # rest of the URL
                        request.get_full_path().replace(
                            script_prefix,
                            '%s%s/' % (script_prefix, language),
                            1
                        )
                    )
                    return self.response_redirect_class(language_url)

            if not (self.is_language_prefix_patterns_used()
                    and language_from_path):
                patch_vary_headers(response, ('Accept-Language',))
            if 'Content-Language' not in response:
                response['Content-Language'] = language
            return response

        def is_language_prefix_patterns_used(self):
            """
            Returns `True` if the `LocaleRegexURLResolver` is used
            at root level of the urlpatterns, else it returns `False`.
            """
            return self._is_language_prefix_patterns_used