django.utils.translation.get_language

Here are the examples of the python api django.utils.translation.get_language taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

178 Examples 7

3 Source : context_processors.py
with GNU General Public License v3.0
from Aghoreshwar

def i18n(request):
    from django.utils import translation
    return {
        'LANGUAGES': settings.LANGUAGES,
        'LANGUAGE_CODE': translation.get_language(),
        'LANGUAGE_BIDI': translation.get_language_bidi(),
    }


def tz(request):

3 Source : i18n.py
with GNU General Public License v3.0
from Aghoreshwar

    def render(self, context):
        context[self.variable] = translation.get_language()
        return ''


class GetCurrentLanguageBidiNode(Node):

3 Source : resolvers.py
with GNU General Public License v3.0
from Aghoreshwar

    def language_prefix(self):
        language_code = get_language() or settings.LANGUAGE_CODE
        if language_code == settings.LANGUAGE_CODE and not self.prefix_default_language:
            return ''
        else:
            return '%s/' % language_code

    def match(self, path):

3 Source : resolvers.py
with GNU General Public License v3.0
from Aghoreshwar

    def reverse_dict(self):
        language_code = get_language()
        if language_code not in self._reverse_dict:
            self._populate()
        return self._reverse_dict[language_code]

    @property

3 Source : resolvers.py
with GNU General Public License v3.0
from Aghoreshwar

    def namespace_dict(self):
        language_code = get_language()
        if language_code not in self._namespace_dict:
            self._populate()
        return self._namespace_dict[language_code]

    @property

3 Source : resolvers.py
with GNU General Public License v3.0
from Aghoreshwar

    def app_dict(self):
        language_code = get_language()
        if language_code not in self._app_dict:
            self._populate()
        return self._app_dict[language_code]

    def _is_callback(self, name):

3 Source : cache.py
with GNU General Public License v3.0
from Aghoreshwar

def _i18n_cache_key_suffix(request, cache_key):
    """If necessary, add the current locale or time zone to the cache key."""
    if settings.USE_I18N or settings.USE_L10N:
        # first check if LocaleMiddleware or another middleware added
        # LANGUAGE_CODE to request, then fall back to the active language
        # which in turn can also fall back to settings.LANGUAGE_CODE
        cache_key += '.%s' % getattr(request, 'LANGUAGE_CODE', get_language())
    if settings.USE_TZ:
        # The datetime module doesn't restrict the output of tzname().
        # Windows is known to use non-standard, locale-dependent names.
        # User-defined tzinfo classes may return absolutely anything.
        # Hence this paranoid conversion to create a valid cache key.
        tz_name = force_text(get_current_timezone_name(), errors='ignore')
        cache_key += '.%s' % tz_name.encode('ascii', 'ignore').decode('ascii').replace(' ', '_')
    return cache_key


def _generate_cache_key(request, method, headerlist, key_prefix):

3 Source : formats.py
with GNU General Public License v3.0
from Aghoreshwar

def get_format_modules(lang=None, reverse=False):
    """Return a list of the format modules found."""
    if lang is None:
        lang = get_language()
    if lang not in _format_modules_cache:
        _format_modules_cache[lang] = list(iter_format_modules(lang, settings.FORMAT_MODULE_PATH))
    modules = _format_modules_cache[lang]
    if reverse:
        return list(reversed(modules))
    return modules


def get_format(format_type, lang=None, use_l10n=None):

3 Source : i18n.py
with GNU General Public License v3.0
from Aghoreshwar

    def get(self, request, *args, **kwargs):
        locale = get_language()
        domain = kwargs.get('domain', self.domain)
        # If packages are not provided, default to all installed packages, as
        # DjangoTranslation without localedirs harvests them all.
        packages = kwargs.get('packages', '')
        packages = packages.split('+') if packages else self.packages
        paths = self.get_paths(packages) if packages else None
        self.translation = DjangoTranslation(locale, domain=domain, localedirs=paths)
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

    def get_paths(self, packages):

3 Source : base.py
with MIT License
from Air-999

def no_translations(handle_func):
    """Decorator that forces a command to run with translations deactivated."""
    def wrapped(*args, **kwargs):
        from django.utils import translation
        saved_locale = translation.get_language()
        translation.deactivate_all()
        try:
            res = handle_func(*args, **kwargs)
        finally:
            if saved_locale is not None:
                translation.activate(saved_locale)
        return res
    return wrapped


class DjangoHelpFormatter(HelpFormatter):

3 Source : resolvers.py
with MIT License
from Air-999

    def app_dict(self):
        language_code = get_language()
        if language_code not in self._app_dict:
            self._populate()
        return self._app_dict[language_code]

    @staticmethod

3 Source : cache.py
with MIT License
from Air-999

def _i18n_cache_key_suffix(request, cache_key):
    """If necessary, add the current locale or time zone to the cache key."""
    if settings.USE_I18N or settings.USE_L10N:
        # first check if LocaleMiddleware or another middleware added
        # LANGUAGE_CODE to request, then fall back to the active language
        # which in turn can also fall back to settings.LANGUAGE_CODE
        cache_key += '.%s' % getattr(request, 'LANGUAGE_CODE', get_language())
    if settings.USE_TZ:
        cache_key += '.%s' % get_current_timezone_name()
    return cache_key


def _generate_cache_key(request, method, headerlist, key_prefix):

3 Source : user_attendance.py
with GNU General Public License v3.0
from auto-mat

    def send_templated_notification(self, template):
        clang = get_language()
        activate(self.userprofile.language)
        try:
            icon_url = template.icon.url
        except ValueError:
            icon_url = ""
        notify.send(
            self,
            recipient=self.userprofile.user,
            verb=template.verb,
            url=template.url,
            icon=icon_url,
            indempotent=True,
            action_object=template,
        )
        activate(clang)

    def revoke_templated_notification(self, template):

3 Source : languages.py
with BSD 3-Clause "New" or "Revised" License
from bbmokhtari

def _get_active_language():
    """Return the `supported language` code of the `active language` code."""
    return _get_supported_language(get_language())


def _get_all_languages():

3 Source : client.py
with GNU General Public License v3.0
from canway

    def get_cur_language(self):
        try:
            from django.utils import translation

            return translation.get_language()
        except Exception:
            return None

    def set_bk_api_ver(self, bk_api_ver):

3 Source : forms.py
with MIT License
from cds-snc

    def save(self, *args, **kwargs):
        cleaned_data = super().clean()
        email = cleaned_data.get("email")
        params = {
            "email": email,
            "inviter": self.request.user,
        }
        instance = Invitation.create(**params)
        instance.send_invitation(self.request, language=get_language())
        # We can't call InvitationAdminForm here, it would try to send 2 invitations
        super(forms.ModelForm, self).save(*args, **kwargs)
        return instance

    class Meta:

3 Source : views.py
with MIT License
from cds-snc

    def form_valid(self, form):
        # Pass user to invite, save the invite to the DB, and return it
        invite = form.save(user=self.request.user)
        if not settings.TESTING:
            # Don't actually send the email during tests
            invite.send_invitation(
                self.request,
                scheme=self.request.scheme,
                language=get_language(),
            )
        self.request.session["invite_email"] = invite.email
        return super().form_valid(form)

    def limit_reached(self):

3 Source : views.py
with MIT License
from cds-snc

    def post(self, *args, **kwargs):
        base_url = self.request.build_absolute_uri("/")
        self.extra_email_context = {
            "base_url": base_url[:-1],  # remove the trailing slash
            "language": get_language(),
        }

        return super().post(*args, **kwargs)


class HealthcarePasswordChangeView(Is2FAMixin, EditPasswordMixin, PasswordChangeView):

3 Source : resolvers.py
with MIT License
from chunky2808

    def __get__(self, instance, cls=None):
        """
        Return a compiled regular expression based on the active language.
        """
        if instance is None:
            return self
        # As a performance optimization, if the given regex string is a regular
        # string (not a lazily-translated string proxy), compile it once and
        # avoid per-language compilation.
        if isinstance(instance._regex, six.string_types):
            instance.__dict__['regex'] = self._compile(instance._regex)
            return instance.__dict__['regex']
        language_code = get_language()
        if language_code not in instance._regex_dict:
            instance._regex_dict[language_code] = self._compile(force_text(instance._regex))
        return instance._regex_dict[language_code]

    def _compile(self, regex):

3 Source : resolvers.py
with MIT License
from chunky2808

    def regex(self):
        language_code = get_language() or settings.LANGUAGE_CODE
        if language_code not in self._regex_dict:
            if language_code == settings.LANGUAGE_CODE and not self.prefix_default_language:
                regex_string = ''
            else:
                regex_string = '^%s/' % language_code
            self._regex_dict[language_code] = re.compile(regex_string, re.UNICODE)
        return self._regex_dict[language_code]

3 Source : cache.py
with MIT License
from chunky2808

def _i18n_cache_key_suffix(request, cache_key):
    """If necessary, adds the current locale or time zone to the cache key."""
    if settings.USE_I18N or settings.USE_L10N:
        # first check if LocaleMiddleware or another middleware added
        # LANGUAGE_CODE to request, then fall back to the active language
        # which in turn can also fall back to settings.LANGUAGE_CODE
        cache_key += '.%s' % getattr(request, 'LANGUAGE_CODE', get_language())
    if settings.USE_TZ:
        # The datetime module doesn't restrict the output of tzname().
        # Windows is known to use non-standard, locale-dependent names.
        # User-defined tzinfo classes may return absolutely anything.
        # Hence this paranoid conversion to create a valid cache key.
        tz_name = force_text(get_current_timezone_name(), errors='ignore')
        cache_key += '.%s' % tz_name.encode('ascii', 'ignore').decode('ascii').replace(' ', '_')
    return cache_key


def _generate_cache_key(request, method, headerlist, key_prefix):

3 Source : formats.py
with MIT License
from chunky2808

def get_format_modules(lang=None, reverse=False):
    """
    Returns a list of the format modules found
    """
    if lang is None:
        lang = get_language()
    if lang not in _format_modules_cache:
        _format_modules_cache[lang] = list(iter_format_modules(lang, settings.FORMAT_MODULE_PATH))
    modules = _format_modules_cache[lang]
    if reverse:
        return list(reversed(modules))
    return modules


def get_format(format_type, lang=None, use_l10n=None):

3 Source : i18n.py
with MIT License
from chunky2808

def _get_locale(request):
    language = request.GET.get(LANGUAGE_QUERY_PARAMETER)
    if not (language and check_for_language(language)):
        language = get_language()
    return to_locale(language)


def _parse_packages(packages):

3 Source : models.py
with MIT License
from creativecommons

    def get_legal_code_for_language_code(self, language_code):
        """
        Return the LegalCode object for this tool and language.
        """
        if not language_code:
            language_code = translation.get_language()
        try:
            return self.legal_codes.get(language_code=language_code)
        except LegalCode.DoesNotExist as e:
            e.args = (f"{e.args[0]} language_code={language_code}",)
            raise

    def get_metadata(self):

3 Source : news_tags.py
with BSD 3-Clause "New" or "Revised" License
from DJWOMS

def get_posts(context, category, order, count):
    """Получаю список статей"""
    if category is not None:
        posts = Post.objects.filter(
            category__name__icontains=category,
            lang=get_language()).order_by(order)
    else:
        posts = Post.objects.filter(lang=get_language()).order_by(order)
    if count is not None:
        posts = posts[:count]
    return posts


def get_categories(context, order, count):

3 Source : news_tags.py
with BSD 3-Clause "New" or "Revised" License
from DJWOMS

def get_categories(context, order, count):
    """Получаю список категорий"""
    categories = Category.objects.filter(published=True, lang=get_language()).order_by(order)
    if count is not None:
        categories = categories[:count]
    return categories


@register.inclusion_tag('base/tags/base_tag.html', takes_context=True)

3 Source : views.py
with BSD 3-Clause "New" or "Revised" License
from DJWOMS

    def get_posts(self):
        return Post.objects.filter(
                lang=get_language(),
                category__published=True,
                published=True,
                published_date__lte=datetime.now()
        )

    def get_queryset(self):

3 Source : views.py
with BSD 3-Clause "New" or "Revised" License
from DJWOMS

    def get_post(self, request, **kwargs):
        post = get_object_or_404(
            Post,
            lang=get_language(),
            slug=kwargs.get("post"),
            category__published=True,
            published=True,
            published_date__lte=datetime.now()
        )
        return post

    def get(self, request, **kwargs):

3 Source : abstract_models.py
with GNU General Public License v3.0
from foonsun

    def get_url_cache_key(self):
        current_locale = get_language()
        cache_key = 'CATEGORY_URL_%s_%s' % (current_locale, self.pk)
        return cache_key

    def get_absolute_url(self):

3 Source : utils.py
with GNU General Public License v3.0
from foonsun

def format_timedelta(td):
    """
    Takes an instance of timedelta and formats it as a readable translated string
    """
    return format_td(
        td,
        threshold=2,
        locale=to_locale(get_language() or settings.LANGUAGE_CODE)
    )


def format_datetime(dt, format=None):

3 Source : faker.py
with GNU General Public License v3.0
from fourdigits

    def __init__(self, provider, **kwargs):
        self.provider = provider
        self.locale = kwargs.pop("locale", get_language())
        self.unique = kwargs.pop("unique", False)
        self.kwargs = kwargs

    def __call__(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_cache_key_i18n_translation(self):
        request = self.factory.get(self.path)
        lang = translation.get_language()
        response = HttpResponse()
        key = learn_cache_key(request, response)
        self.assertIn(lang, key, "Cache keys should include the language name when translation is active")
        key2 = get_cache_key(request)
        self.assertEqual(key, key2)

    def check_accept_language_vary(self, accept_language, vary, reference_key):

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_cache_key_i18n_formatting(self):
        request = self.factory.get(self.path)
        lang = translation.get_language()
        response = HttpResponse()
        key = learn_cache_key(request, response)
        self.assertIn(lang, key, "Cache keys should include the language name when formatting is active")
        key2 = get_cache_key(request)
        self.assertEqual(key, key2)

    @override_settings(USE_I18N=False, USE_L10N=False, USE_TZ=True)

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_cache_key_no_i18n(self):
        request = self.factory.get(self.path)
        lang = translation.get_language()
        tz = force_text(timezone.get_current_timezone_name(), errors='ignore')
        tz = tz.encode('ascii', 'ignore').decode('ascii').replace(' ', '_')
        response = HttpResponse()
        key = learn_cache_key(request, response)
        self.assertNotIn(lang, key, "Cache keys shouldn't include the language name when i18n isn't active")
        self.assertNotIn(tz, key, "Cache keys shouldn't include the time zone name when i18n isn't active")

    @override_settings(USE_I18N=False, USE_L10N=False, USE_TZ=True)

3 Source : tests.py
with Apache License 2.0
from gethue

    def test_override(self):
        activate('de')
        try:
            with translation.override('pl'):
                self.assertEqual(get_language(), 'pl')
            self.assertEqual(get_language(), 'de')
            with translation.override(None):
                self.assertIsNone(get_language())
                with translation.override('pl'):
                    pass
                self.assertIsNone(get_language())
            self.assertEqual(get_language(), 'de')
        finally:
            deactivate()

    def test_override_decorator(self):

3 Source : tests.py
with Apache License 2.0
from gethue

    def setUp(self):
        self._old_language = get_language()
        self._translations = trans_real._translations

        # here we rely on .split() being called inside the _fetch()
        # in trans_real.translation()
        class sideeffect_str(str):
            def split(self, *args, **kwargs):
                res = str.split(self, *args, **kwargs)
                trans_real._translations['en-YY'] = None
                return res

        trans_real._translations = {sideeffect_str('en-XX'): None}

    def tearDown(self):

3 Source : test_percents.py
with Apache License 2.0
from gethue

    def setUp(self):
        self._language = get_language()
        self._translations = trans_real._translations
        activate('fr')

    def tearDown(self):

3 Source : test_i18n.py
with Apache License 2.0
from gethue

    def _get_inactive_language_code(self):
        """Return language code for a language which is not activated."""
        current_language = get_language()
        return [code for code, name in settings.LANGUAGES if not code == current_language][0]

    def test_setlang(self):

3 Source : test_models.py
with Apache License 2.0
from gethue

    def setUp(self):
        from django.utils import translation
        self.saved_locale = translation.get_language()
        translation.deactivate_all()

    def tearDown(self):

3 Source : middleware.py
with Apache License 2.0
from gethue

    def process_request(self, request):
        try:
            code = getattr(request, 'LANGUAGE_CODE', get_language())
            locale = Locale.parse(code, sep='-')
        except (ValueError, UnknownLocaleError):
            pass
        else:
            _thread_locals.locale = request.locale = locale

3 Source : babel.py
with Apache License 2.0
from gethue

def _get_format():
    locale = get_current_locale()
    if not locale:
        locale = babel_core.Locale.parse(to_locale(get_language()))
    if timezone:
        tzinfo = timezone(settings.TIME_ZONE)
    else:
        tzinfo = None
    return babel_support.Format(locale, tzinfo)


@register.filter

3 Source : scripts.py
with Apache License 2.0
from google

  def get_description(self, variables={}):
    script_buffer = self.script.get('script', {})
    return text_set_fields(
      script_buffer.get(get_language(), script_buffer).get('description', ''),
      variables
    )

  def get_instructions(self, variables={}):

3 Source : scripts.py
with Apache License 2.0
from google

  def get_instructions(self, variables={}):
    script_buffer = self.script.get('script', {})
    return [
      text_set_fields(instruction, variables)
      for instruction in script_buffer.get(get_language(), script_buffer).get('instructions', '')
    ]

  def get_documentation(self):

3 Source : views.py
with GNU General Public License v3.0
from jonaswinkler

    def get_language(self):
        # This is here for the following reason:
        # Django identifies languages in the form "en-us"
        # However, angular generates locales as "en-US".
        # this translates between these two forms.
        lang = get_language()
        if "-" in lang:
            first = lang[:lang.index("-")]
            second = lang[lang.index("-")+1:]
            return f"{first}-{second.upper()}"
        else:
            return lang

    def get_context_data(self, **kwargs):

3 Source : models.py
with MIT License
from jroslaniec

    def _dispatch(self):
        cur_language = translation.get_language()
        try:
            translation.activate(self.language)
            self._send()
        except Exception as exc:
            self.set_status(Msg.Status.ERROR, save=True)
            raise exc
        finally:
            translation.activate(cur_language)

        self.set_status(Msg.Status.DONE, save=True)

    def _send(self):

3 Source : views.py
with GNU General Public License v3.0
from JustFixNYC

def _render_decl_pdf(v: HardshipDeclarationVariables, filename: str):
    locale = get_language()
    b = hardship_declaration.fill_hardship_pdf(v, locale)
    return FileResponse(BytesIO(b), filename=filename)


def render_example_declaration_pdf(request):

3 Source : middleware.py
with BSD 3-Clause "New" or "Revised" License
from Kenstogram

def google_analytics(get_response):
    """Report a page view to Google Analytics."""
    def middleware(request):
        client_id = analytics.get_client_id(request)
        path = request.path
        language = get_language()
        headers = request.META
        try:
            analytics.report_view(
                client_id, path=path, language=language, headers=headers)
        except Exception:
            logger.exception('Unable to update analytics')
        return get_response(request)
    return middleware


def discounts(get_response):

3 Source : manythings.py
with BSD 3-Clause "New" or "Revised" License
from linuxsoftware

def _n2w(n, to):
    try:
        return num2words(n, lang=to_locale(get_language()), to=to)
    except NotImplementedError:
        # fall back to gettext for these words
        gettext_noop("first")
        gettext_noop("second")
        gettext_noop("third")
        gettext_noop("fourth")
        gettext_noop("fifth")
        return _(num2words(n, lang="en", to=to))

# ------------------------------------------------------------------------------
def toOrdinal(n):

3 Source : manythings.py
with BSD 3-Clause "New" or "Revised" License
from linuxsoftware

def toDaysOffsetStr(offset):
    retval = ""
    if offset   <  = -2:
        n = num2words(-offset, lang=to_locale(get_language()), to="cardinal")
        retval = _("{N} days before").format(N=n.capitalize())
    elif offset == -1:
        retval = _("The day before")
    elif offset == 1:
        retval = _("The day after")
    elif offset >= 2:
        n = num2words(offset, lang=to_locale(get_language()), to="cardinal")
        retval = _("{N} days after").format(N=n.capitalize())
    return retval

# ------------------------------------------------------------------------------
def hrJoin(items):

3 Source : utils.py
with MIT License
from LowerDeez

def get_locale(request: 'HttpRequest') -> str:
    """
    Return locale like `en_GB`
    """
    if request and hasattr(request, 'LANGUAGE_CODE'):
        language = request.LANGUAGE_CODE
    else:
        language = get_language()
    code = locale_alias.get(language)
    if code and '.' in code:
        locale_tuple = tuple(code.split('.')[:2])
        try:
            return locale_tuple[0]
        except IndexError:
            pass
    return to_locale(language)


def get_i18n_context() -> Dict[str, Union[Tuple[str, str], str]]:

See More Examples