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
3
Source : context_processors.py
with GNU General Public License v3.0
from Aghoreshwar
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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