python类LANGUAGE_CODE的实例源码

def __call__(self, request):
        if request.path.startswith('/admin'):
            request.LANG = getattr(settings, 'ADMIN_LANGUAGE_CODE',
                                   settings.LANGUAGE_CODE)
            translation.activate(request.LANG)
            request.LANGUAGE_CODE = request.LANG
        else:
            request.LANG = settings.LANGUAGE_CODE
            translation.activate(request.LANG)
            request.LANGUAGE_CODE = request.LANG

        return self.get_response(request)

def serve(self, request, *args, **kwargs):
        activate(self.language.code)
        request.LANGUAGE_CODE = self.language.code
        return super(TranslatedPage, self).serve(request, *args, **kwargs)

def make_wsgi_application():
    # validate models
    s = StringIO()
    if get_validation_errors(s):
        s.seek(0)
        error = s.read()
        msg = "One or more models did not validate:\n%s" % error
        print(msg, file=sys.stderr)
        sys.stderr.flush()
        sys.exit(1)

    translation.activate(settings.LANGUAGE_CODE)
    if django14:
        return get_internal_wsgi_application()
    return WSGIHandler()

def get_translated_attribute(instance, attr):
    """
    Wraps Django Model __getattribute__ method making translation in templates less painful
    """

    # If its class has no translatable fields, returns attribute
    try:
        if not hasattr(instance._meta, "translatable_fields") or len(getattr(instance._meta,"translatable_fields"))==0:
            return getattr(instance, attr)
    except AttributeError:
        return instance

    # Translatable fields of this instance
    translatable_fields = instance._meta.translatable_fields

    # Current language
    cur_language = get_language()
    lang = cur_language.title().lower()

    # If current language is default language, returns attribute
    if lang == settings.LANGUAGE_CODE:
        return getattr(instance, attr)

    # Otherwise, if a translation is NOT needed for attr atribute, get attribute
    if not attr in translatable_fields:
        return getattr(instance, attr)

    # Gets field translations of this instance and return the translated attribute
    field_translation = _get_fieldtranslations(instance, field=attr, lang=lang)
    if field_translation:
        if not field_translation.is_fuzzy:
            return field_translation.translation
    return getattr(instance, attr)


# Register this template filter

def _save_translations(sender, instance, *args, **kwargs):
    """
    This signal saves model translations.
    """

    # If we are in a site with one language there is no need of saving translations
    if site_is_monolingual():
        return False

    cls = sender

    # If its class has no "translatable_fields" then there are no translations
    if not hasattr(cls._meta, "translatable_fields"):
        return False

    # For each translatable field, get its value, computes its md5 and for each language creates its
    # empty translation.
    for field in cls._meta.translatable_fields:
        value = getattr(instance,field)
        if not value is None:
            md5_value = checksum(value)
            setattr( instance, u"md5"+field, md5_value )
            for lang in settings.LANGUAGES:
                lang = lang[0]
                # print "({0}!={1}) = {2}".format(lang, settings.LANGUAGE_CODE,lang!=settings.LANGUAGE_CODE)
                if lang != settings.LANGUAGE_CODE:
                    context = u"Updating from object"
                    if hasattr(instance, "trans_context"):
                        context = getattr(instance, "trans_context")
                    trans = FieldTranslation.update(instance, field, lang, context)


########################################################################
########################################################################
########################################################################
## GET TRANSLATIONS ##


########################################################################################################################
## Get translated fields

def akismet_comment_check(request, comment):
    """Akismet comment check"""
    if settings.ENABLE_AKISMET:
        url_verify_key = 'https://rest.akismet.com/1.1/verify-key'
        key = settings.AKISMET_API_KEY
        blog = settings.BLOG_URL
        data = {'key': key, 'blog': blog}

        response = requests.post(url_verify_key, data=data)
        if response.text == 'valid':
            url = 'https://%s.rest.akismet.com/1.1/comment-check' % key
            data = {
                'blog': blog,
                'user_ip': comment.ip,
                'user_agent': get_useragent(request),
                'referrer': get_referrer(request),
                'comment_type': 'comment',
                'comment_author': comment.username,
                'comment_content': comment.content,
                'comment_date_gmt': timezone.now(),
                'blog_lang': settings.LANGUAGE_CODE,
                'blog_charset': 'UTF-8',
            }

            result = requests.post(url, data=data)
            if result.text == 'true':
                return True
    return False

def get_translation(self, language=settings.LANGUAGE_CODE):
        return self.__class__.objects.get(translation=self, language=language)

def select_language(context, current_code=None):
    request = context.get('request')
    if not request:
        return ''

    current_code = current_code or get_language()
    if not current_code or current_code not in options.MULTILANGUAGE_SITES:
        current_code = settings.LANGUAGE_CODE

    return loader.render_to_string('multilanguage/allowed_languages.html', {
        'current_code': current_code,
        'langs': options.MULTILANGUAGE_SITES,
    }, request=request)

def get_formatter(language=None):
    if conf.VALUTE_FORMAT:
        valute_format = conf.VALUTE_FORMAT
    else:
        language = language or get_language() or settings.LANGUAGE_CODE
        for langs, valute_format in conf.VALUTE_FORMAT_BY_LANG.items():
            if language in langs:
                break
        else:
            raise ImproperlyConfigured("Valute format not found for language '%s'" % language)

    return conf.VALUTE_FORMATS[valute_format.upper()]

def __init__(self, language=None, attrs=None):
        self.language = language or settings.LANGUAGE_CODE[:2]
        super(ColorPickerWidget, self).__init__(attrs=attrs)

def make_wsgi_application():
    # validate models
    s = StringIO()
    if get_validation_errors(s):
        s.seek(0)
        error = s.read()
        msg = "One or more models did not validate:\n%s" % error
        print(msg, file=sys.stderr)
        sys.stderr.flush()
        sys.exit(1)

    translation.activate(settings.LANGUAGE_CODE)
    if django14:
        return get_internal_wsgi_application()
    return WSGIHandler()

def update(self, index, iterable, commit=True, language_specific=False):
        if not language_specific and self.connection_alias == "default":
            current_language = (translation.get_language() or settings.LANGUAGE_CODE)[:2]
            for lang_code, lang_name in settings.LANGUAGES:
                using = "default_%s" % lang_code
                translation.activate(lang_code)
                backend = connections[using].get_backend()
                backend.update(index, iterable, commit, language_specific=True)
            translation.activate(current_language)
        elif language_specific:
            super(MultilingualWhooshSearchBackend, self).update(index, iterable, commit)

def index_queryset(self, using=None):
        """Used when the entire index for model is updated."""
        if using and using != "default":
            lang_code = using.replace("default_", "")
        else:
            lang_code = settings.LANGUAGE_CODE[:2]
        return self.get_model().objects.filter(language=lang_code)

def handle(self, *args, **options):
        warnings.warn(
            "FastCGI support has been deprecated and will be removed in Django 1.9.",
            RemovedInDjango19Warning)

        from django.conf import settings
        from django.utils import translation
        # Activate the current language, because it won't get activated later.
        try:
            translation.activate(settings.LANGUAGE_CODE)
        except AttributeError:
            pass
        from django.core.servers.fastcgi import runfastcgi
        runfastcgi(args)

def process_request(request):
        if request.path.startswith('/admin'):
            request.LANG = getattr(settings, 'ADMIN_LANGUAGE_CODE', settings.LANGUAGE_CODE)
            translation.activate(request.LANG)
            request.LANGUAGE_CODE = request.LANG
        else:
            request.LANG = settings.LANGUAGE_CODE
            translation.activate(request.LANG)
            request.LANGUAGE_CODE = request.LANG

def make_wsgi_application():
    # validate models
    s = StringIO()
    if get_validation_errors(s):
        s.seek(0)
        error = s.read()
        msg = "One or more models did not validate:\n%s" % error
        print(msg, file=sys.stderr)
        sys.stderr.flush()
        sys.exit(1)

    translation.activate(settings.LANGUAGE_CODE)
    if django14:
        return get_internal_wsgi_application()
    return WSGIHandler()

def get_targets(combine_media=settings.COMBINE_MEDIA, **kwargs):
    """Returns all files that must be combined."""
    targets = []
    for target in sorted(combine_media.keys()):
        group = combine_media[target]
        if '.site_data.js' in group:
            # site_data must always come first because other modules might
            # depend on it
            group.remove('.site_data.js')
            group.insert(0, site_data)
        if '%(LANGUAGE_CODE)s' in target:
            # This file uses i18n, so generate a separate file per language.
            # The language data is always added before all other files.
            for LANGUAGE_CODE in LANGUAGES:
                data = kwargs.copy()
                data['LANGUAGE_CODE'] = LANGUAGE_CODE
                filename = target % data
                data['target'] = filename
                group.insert(0, lang_data)
                targets.append((filename, data, group))
        elif '%(LANGUAGE_DIR)s' in target:
            # Generate CSS files for both text directions
            for LANGUAGE_DIR in ('ltr', 'rtl'):
                data = kwargs.copy()
                data['LANGUAGE_DIR'] = LANGUAGE_DIR
                filename = target % data
                data['target'] = filename
                targets.append((filename, data, group))
        else:
            data = kwargs.copy()
            filename = target % data
            data['target'] = filename
            targets.append((filename, data, group))
    return targets

def translate(func):
    @wraps(func)
    def _inner(*args, **kwargs):
        lang = kwargs.pop('language', settings.LANGUAGE_CODE)
        prev_lang = translation.get_language()
        translation.activate(lang)
        try:
            ret = func(*args, **kwargs)
        finally:
            translation.activate(prev_lang)
        return ret
    return _inner

def make_wsgi_application():
    # validate models
    s = StringIO()
    if get_validation_errors(s):
        s.seek(0)
        error = s.read()
        msg = "One or more models did not validate:\n%s" % error
        print(msg, file=sys.stderr)
        sys.stderr.flush()
        sys.exit(1)

    translation.activate(settings.LANGUAGE_CODE)
    if django14:
        return get_internal_wsgi_application()
    return WSGIHandler()

def handle(self, *args, **options):
        warnings.warn(
            "FastCGI support has been deprecated and will be removed in Django 1.9.",
            RemovedInDjango19Warning)

        from django.conf import settings
        from django.utils import translation
        # Activate the current language, because it won't get activated later.
        try:
            translation.activate(settings.LANGUAGE_CODE)
        except AttributeError:
            pass
        from django.core.servers.fastcgi import runfastcgi
        runfastcgi(args)