def test_locale_comparison(self):
en_US = Locale('en', 'US')
self.assertEqual(en_US, en_US)
self.assertNotEqual(None, en_US)
bad_en_US = Locale('en_US')
self.assertNotEqual(en_US, bad_en_US)
def settarget(self, target):
if (self.hasplurals(self.source) or self.hasplurals(target)):
# Fix the root tag if mismatching
if self.xmlelement.tag != "plurals":
old_id = self.getid()
self.xmlelement = etree.Element("plurals")
self.xmlelement.tail = '\n'
self.setid(old_id)
try:
lang_tags = set(Locale(self.gettargetlanguage()).plural_form.tags)
except UnknownLocaleError:
lang_tags = set(Locale('en').plural_form.tags)
# Ensure that the implicit default "other" rule is present (usually omitted by Babel)
lang_tags.add('other')
# Get plural tags in the right order.
plural_tags = [tag for tag in ['zero', 'one', 'two', 'few', 'many', 'other'] if tag in lang_tags]
# Get string list to handle, wrapping non multistring/list targets into a list.
if isinstance(target, multistring):
plural_strings = target.strings
elif isinstance(target, list):
plural_strings = target
else:
plural_strings = [target]
# Sync plural_strings elements to plural_tags count.
if len(plural_strings) < len(plural_tags):
plural_strings += [''] * (len(plural_tags) - len(plural_strings))
plural_strings = plural_strings[:len(plural_tags)]
# Rebuild plurals.
for entry in self.xmlelement.iterchildren():
self.xmlelement.remove(entry)
self.xmlelement.text = "\n\t"
for plural_tag, plural_string in zip(plural_tags, plural_strings):
item = etree.Element("item")
item.set("quantity", plural_tag)
self.set_xml_text_value(plural_string, item)
item.tail = "\n\t"
self.xmlelement.append(item)
# Remove the tab from last item
item.tail = "\n"
else:
# Fix the root tag if mismatching
if self.xmlelement.tag != "string":
old_id = self.getid()
self.xmlelement = etree.Element("string")
self.xmlelement.tail = '\n'
self.setid(old_id)
self.set_xml_text_value(target, self.xmlelement)
super(AndroidResourceUnit, self).settarget(target)
def test_locale_comparison():
en_US = Locale('en', 'US')
en_US_2 = Locale('en', 'US')
fi_FI = Locale('fi', 'FI')
bad_en_US = Locale('en_US')
assert en_US == en_US
assert en_US == en_US_2
assert en_US != fi_FI
assert not (en_US != en_US_2)
assert en_US is not None
assert en_US != bad_en_US
assert fi_FI != bad_en_US
def test_locale_gets_overridden_by_file(self):
buf = StringIO(r'''
msgid ""
msgstr ""
"Language: en_US\n"''')
catalog = pofile.read_po(buf, locale='de')
self.assertEqual(Locale('en', 'US'), catalog.locale)
buf = StringIO(r'''
msgid ""
msgstr ""
"Language: ko-KR\n"''')
catalog = pofile.read_po(buf, locale='de')
self.assertEqual(Locale('ko', 'KR'), catalog.locale)
def get_accepted_languages() -> List[str]:
"""
Convert a request's list of accepted languages into locale identifiers.
"""
accept_languages = []
for l in request.accept_languages.values():
try:
parsed = Locale.parse(l, "-")
accept_languages.append(str(parsed))
# We only have two Chinese translations, simplified
# and traditional, based on script and not
# region. Browsers tend to send identifiers with
# region, e.g. zh-CN or zh-TW. Babel can generally
# infer the script from those, so we can fabricate a
# fallback entry without region, in the hope that it
# will match one of our translations and the site will
# at least be more legible at first contact than the
# probable default locale of English.
if parsed.language == "zh" and parsed.script:
accept_languages.append(
str(Locale(language=parsed.language,
script=parsed.script)))
except (ValueError, UnknownLocaleError):
pass
return accept_languages
def _parse_page_basename(self, basename):
"""Split the page basename into the article id and locale.
`basename` is (supposed to be) of the form
`<article_id>.<locale>`, e.g. `news.en`.
If either there is no dot or the locale is unknown,
the `default_locale` of babel is used.
:return: The tuple `(article_id, locale)`.
"""
default_locale = self.extension.app.babel_instance.default_locale
article_id, sep, locale_identifier = basename.rpartition('.')
if sep == '':
return basename, default_locale
try:
locale = Locale(locale_identifier)
except UnknownLocaleError:
logger.error("Unknown locale %s of arcticle %s",
locale_identifier, basename)
return basename, default_locale
if locale not in possible_locales():
logger.warning("Locale %s of article is not a possible locale",
locale_identifier, basename)
return basename, default_locale
return article_id, locale
def test_format_number(self, format_number):
ctx = {'LANG': 'de'}
locale = Locale('de')
eq_(helpers.l10n_format_number(ctx, 10000),
format_number.return_value)
format_number.assert_called_with(
10000, locale=locale)
def test_format_number_hyphenated_locale(self, format_number):
ctx = {'LANG': 'pt-BR'}
locale = Locale('pt', 'BR')
eq_(helpers.l10n_format_number(ctx, 10000),
format_number.return_value)
format_number.assert_called_with(
10000, locale=locale)
def get_metadata(app, docname):
'''
Extracts metadata from a document.
'''
env = app.builder.env
language = app.config.language
locale = Locale.parse(language) if language else Locale('en', 'US')
format_ui_date = partial(
format_date, format=UIStr.TIMESTAMP_FMT, locale=locale)
format_short_ui_short = partial(
format_date, format=UIStr.TIMESTAMP_FMT_SHORT, locale=locale)
env.blog_metadata[docname] = Metadata()
metadata = env.blog_metadata[docname]
# if it's a page
if docname.startswith("pages/"):
metadata.is_page = True
return
# posts are identified by ($YEAR)/($MONTH)/($DAY) paths
match = re.match(r"\d{4}/\d{2}/\d{2}/", docname)
# if not post return
if not match:
return
metadata.is_post = True
metadata.link = docname
metadata.date = datetime.datetime.strptime(match.group(), "%Y/%m/%d/")
# we format date here instead of inside template due to localization issues
# and Python2 vs Python3 incompatibility
metadata.formatted_date = format_ui_date(metadata.date)
metadata.formatted_date_short = format_short_ui_short(metadata.date)
def extract_and_update_locale_dir(dirname, mapping):
locale_dir = os.path.join(dirname, 'locale')
for domain in ('django', 'djangojs'):
extracted_catalog = Catalog()
extracted = extract_from_dir(
dirname=dirname,
method_map=mapping[domain]['method_map'],
options_map=mapping[domain]['options_map']
)
for filename, lineno, message, comments, context in extracted:
extracted_catalog.add(message, None, [(filename, lineno)], auto_comments=comments, context=context)
for locale, language in settings.LANGUAGES:
po_path = os.path.join(locale_dir, locale, 'LC_MESSAGES', '%s.po' % domain)
if os.path.exists(po_path):
with open(po_path, 'rb') as po_fileobj:
catalog = read_po(po_fileobj, locale=locale, domain=domain)
if catalog._messages != extracted_catalog._messages:
catalog.update(extracted_catalog, no_fuzzy_matching=True, update_header_comment=False)
with open(po_path, 'wb') as po_fileobj:
write_po(po_fileobj, catalog, ignore_obsolete=True)
elif extracted_catalog._messages:
extracted_catalog.locale = Locale(locale)
extracted_catalog.domain = domain
extracted_catalog.project = 'Mesto.UA'
extracted_catalog.copyright_holder = 'Mesto.UA'
extracted_catalog.fuzzy = False
touch_directory(po_path)
with open(po_path, 'wb') as po_fileobj:
write_po(po_fileobj, extracted_catalog)
def test_unknown(self):
"""
Test that when the current locale is not supported by Babel, it
defaults to en-US.
"""
activate('fy')
eq_(Locale('en', 'US'), current_locale())
def get_locale(lang):
"""Return a babel Locale object for lang. defaults to LANGUAGE_CODE."""
lang = babel_format_locale_map.get(lang) or lang
try:
return Locale.parse(lang, sep="-")
except (UnknownLocaleError, ValueError):
return Locale(*settings.LANGUAGE_CODE.split("-"))
def parse(self) -> PriceRequest:
text = self.text
obj = AMOUNT_PATTERN_COMPILED.match(text)
if not obj:
raise WrongFormatException
amount = obj[0]
if amount:
amount = parse_amount(amount, self.locale)
last_request = (Session.query(ChatRequests).filter_by(
chat_id=self.chat_id).order_by(
ChatRequests.modified_at.desc()).first())
if not last_request:
raise WrongFormatException
locale = Locale(self.locale)
if locale.character_order == "right-to-left":
direction_writing = DirectionWriting.RIGHT2LEFT
else:
direction_writing = DirectionWriting.LEFT2RIGHT
return PriceRequest(
amount=amount,
currency=last_request.from_currency.code,
to_currency=last_request.to_currency.code,
parser_name=self.name,
direction_writing=direction_writing,
)
def _babel_locale():
"""Return the current locale in Babel's format."""
try:
return Locale.parse(get_language(), sep='-')
except UnknownLocaleError:
# Default to en-US
return Locale('en', 'US')
def test_format_date_hyphenated_locale(self, format_date):
ctx = {'LANG': 'en-US'}
locale = Locale('en', 'US')
eq_(helpers.l10n_format_date(ctx, 'somedate', format='long'),
format_date.return_value)
format_date.assert_called_with(
'somedate', locale=locale, format='long')
def load_i18n(project_root, tell_sentry):
# Load the locales
localeDir = os.path.join(project_root, 'i18n', 'core')
locales = LOCALES
for file in os.listdir(localeDir):
try:
parts = file.split(".")
if not (len(parts) == 2 and parts[1] == "po"):
continue
lang = parts[0]
with open(os.path.join(localeDir, file)) as f:
l = locales[lang.lower()] = Locale(lang)
c = l.catalog = read_po(f)
c.plural_func = get_function_from_rule(c.plural_expr)
try:
l.countries = make_sorted_dict(COUNTRIES, l.territories)
except KeyError:
l.countries = COUNTRIES
try:
l.languages_2 = make_sorted_dict(LANGUAGES_2, l.languages)
except KeyError:
l.languages_2 = LANGUAGES_2
except Exception as e:
tell_sentry(e, {})
# Add aliases
for k, v in list(locales.items()):
locales.setdefault(ALIASES.get(k, k), v)
locales.setdefault(ALIASES_R.get(k, k), v)
for k, v in list(locales.items()):
locales.setdefault(k.split('_', 1)[0], v)
# Patch the locales to look less formal
locales['fr'].currency_formats[None] = parse_pattern('#,##0.00\u202f\xa4')
locales['fr'].currency_symbols['USD'] = '$'
def main(src, dst):
locales = []
for f in path.path(src).walkfiles('messages.po'):
print f
lang = f.split('/')[1]
locales.append(lang.replace('_', '-'))
print lang
try:
locale = Locale(lang)
except UnknownLocaleError:
print 'Unknown locale:', lang
locale = Locale(DEFAULT)
out = path.path(dst) / lang
if not out.exists():
out.makedirs()
d = {
'po': json.dumps(po_to_dict(f), separators=(',', ':')),
'timefmt': locale.time_formats['short'].pattern,
'numfmt': locale.decimal_formats[None].pattern,
'group': locale.number_symbols['group']
}
print '% 5s %8s %s %s' % (lang, d['timefmt'], d['group'], d['numfmt'])
with codecs.open(out / 'l10n.js', 'w', 'utf-8') as fd:
fd.write(template % d)
default = path.path('locale/countries/en-US.json')
countries = path.path('locale/countries/%s.json' %
lang.replace('_', '-'))
regions = path.path('locale/%s/regions.json' % lang)
cities = path.path('locale/%s/cities.json' % lang)
if not countries.exists():
print '*' * 30, 'missing', lang
countries = default
with codecs.open(out / 'countries.js', 'w', 'utf-8') as fd:
d = dict(
(k.upper(), v) for k, v in json.load(countries.open()).items())
if regions.exists():
print 'Adding regions for', lang
d.update(json.load(regions.open()))
if cities.exists():
print 'Adding cities for', lang
d.update(json.load(cities.open()))
fd.write('var _countries = %s;' %
json.dumps(d, separators=(',', ':')))
lo = ["'%s'" % x.lower() for x in locales]
print '$locales = array(%s);' % ', '.join(lo)
def _get_babel_locale(red_locale: str) -> babel.core.Locale:
supported_locales = babel.localedata.locale_identifiers()
try: # Handles cases where red_locale is already Babel supported
babel_locale = Locale(*babel.parse_locale(red_locale))
except (ValueError, babel.core.UnknownLocaleError):
try:
babel_locale = Locale(*babel.parse_locale(red_locale, sep="-"))
except (ValueError, babel.core.UnknownLocaleError):
# ValueError is Raised by `parse_locale` when an invalid Locale is given to it
# Lets handle it silently and default to "en_US"
try:
# Try to find a babel locale that's close to the one used by red
babel_locale = Locale(Locale.negotiate([red_locale], supported_locales, sep="-"))
except (ValueError, TypeError, babel.core.UnknownLocaleError):
# If we fail to get a close match we will then default to "en_US"
babel_locale = Locale("en", "US")
return babel_locale
def test_format_date_hyphenated_locale(self, format_date):
ctx = {"LANG": "en-US"}
locale = Locale("en", "US")
assert helpers.l10n_format_date(
ctx, "somedate", format="long") == format_date.return_value
format_date.assert_called_with("somedate",
locale=locale,
format="long")
def test_format_date(self, format_date):
ctx = {'LANG': 'de'}
locale = Locale('de')
assert (helpers.l10n_format_date(
ctx, 'somedate', format='long') == format_date.return_value)
format_date.assert_called_with('somedate',
locale=locale,
format='long')
def format_date(dt, locale_name=None, format="medium"):
"""Returns a prettyfied version of a date. If a locale_name is
provided the date will be localized. Without a locale the
datetime will be formatted into the form YYYY-MM-DD hh:ss"""
if locale_name:
locale = Locale(locale_name)
return babel_format_date(dt, locale=locale, format=format)
return dt.strftime("%Y-%m-%d")
def __init__(self, request):
self.request = request
self.context = request.context
self.root = request.root
self.locale = Locale(request.locale_name)
self.display_days = int(request.registry.settings['display_days'])
self.delta_period = (datetime.datetime.now() -
datetime.timedelta(days=self.display_days))
self.fd = format_datetime
def current_locale():
"""
Return the current Locale object (from Babel). Defaults to locale
based on settings.LANGUAGE_CODE if locale does not exist.
"""
try:
return Locale.parse(get_language(), sep='-')
except (UnknownLocaleError, ValueError):
return Locale(*settings.LANGUAGE_CODE.split('-'))
def load_i18n(project_root, tell_sentry):
# Load the locales
key = lambda t: strip_accents(t[1])
localeDir = os.path.join(project_root, 'i18n', 'core')
locales = i18n.LOCALES
for file in os.listdir(localeDir):
try:
parts = file.split(".")
if not (len(parts) == 2 and parts[1] == "po"):
continue
lang = parts[0]
with open(os.path.join(localeDir, file)) as f:
l = locales[lang.lower()] = Locale(lang)
c = l.catalog = read_po(f)
c.plural_func = get_function_from_rule(c.plural_expr)
try:
l.countries_map = {
k: l.territories[k]
for k in COUNTRIES_MAP
}
l.countries = sorted(l.countries_map.items(), key=key)
except KeyError:
l.countries_map = COUNTRIES_MAP
l.countries = COUNTRIES
except Exception as e:
tell_sentry(e)
# Add the default English locale
locale_en = i18n.LOCALE_EN = locales['en'] = Locale('en')
locale_en.catalog = Catalog('en')
locale_en.catalog.plural_func = lambda n: n != 1
locale_en.countries = COUNTRIES
locale_en.countries_map = COUNTRIES_MAP
# Add aliases
for k, v in list(locales.items()):
locales.setdefault(ALIASES.get(k, k), v)
locales.setdefault(ALIASES_R.get(k, k), v)
for k, v in list(locales.items()):
locales.setdefault(k.split('_', 1)[0], v)
# Patch the locales to look less formal
locales['fr'].currency_formats[None] = parse_pattern('#,##0.00\u202f\xa4')
locales['fr'].currency_symbols['USD'] = '$'
def current_locale():
"""
Return the current Locale object (from Babel). Defaults to en-US if locale
does not exist.
"""
try:
return Locale.parse(get_language(), sep='-')
except UnknownLocaleError:
# Default to en-US
return Locale('en', 'US')
def get_human_size(value, request=None):
"""Convert given bytes value in human readable format
"""
if request is None:
request = check_request()
translate = request.localizer.translate
try:
locale = Locale(request.locale_name)
except UnknownLocaleError:
locale = Locale(
request.registry.settings.get('pyramid.default_locale_name', 'en'))
if value < 1024:
return format_decimal(value, translate(_('0 bytes')), locale)
value /= 1024
if value < 1024:
return format_decimal(value, translate(_('0.# Kb')), locale)
value /= 1024
if value < 1024:
return format_decimal(value, translate(_('0.0# Mb')), locale)
value /= 1024
return format_decimal(value, translate(_('0.0## Gb')), locale)
def get_languages():
"return a list of supported languages"
langs = (lang for lang in os.listdir(I18NPATH)
if os.path.isdir(os.path.join(I18NPATH, lang)))
def dictify(lang, name):
"map function to make dict"
retdict = {}
retdict[lang] = name
return retdict
return (dictify(lang, Locale(lang).display_name)
for lang in langs if check_language(lang))
def render_table(
locale: Locale,
table: Table,
source: Optional[str] = None,
) -> str:
supported_locale_map: Mapping[str, AbstractSet[Locale]] = {
locale.language:
{l
for l in table.supported_locales if l.language == locale.language}
for locale in table.supported_locales
}
locales: Mapping[str, Union[Locale, Mapping[str, Locale]]] = {
l: next(iter(ls)) if len(ls) == 1 else {
'_': Locale(l),
**{
l.territory: l
for l in sorted(ls,
key=lambda l: (
l != locale,
l.territory != locale.territory,
get_territory_name(l.territory, locale),
))
}
}
for l, ls in sorted(supported_locale_map.items(),
key=lambda pair: (
pair[0] != 'en',
pair[0] != locale.language,
Locale(pair[0]).get_display_name(locale),
))
}
return table_template.render(
locale=locale,
locales=locales,
table=table,
source=source,
)
def _format_resource_items(self, items):
"""
this wraps default implementation and for fields from custom schema
it applies localized labels and values if possible
"""
out = h.format_resource_items(items)
new_out = []
for key, val in items:
if key == 'lang' and val:
key = _("Language")
loc = Locale(val)
val = u'{} [{}]'.format(loc.display_name or loc.english_name,
str(loc))
new_out.append((key, val))
return new_out
def defaultLocale():
try:
lang, _ = locale.getdefaultlocale()
except Exception:
lang = None
if lang is not None:
try:
return Locale.parse(lang)
except UnknownLocaleError:
pass
else:
try:
return Locale.default()
except UnknownLocaleError:
return Locale('en', 'US')
