mirror of
https://github.com/janeczku/calibre-web
synced 2024-12-25 17:40:31 +00:00
bbf6d9b026
Bugfix for feeds
- removed categories related and up
- load new books now working
- category random now working
login page is free of non accessible elements
boolean custom column is vivible in UI
books with only with certain languages can be shown
book shelfs can be deleted from UI
Anonymous user view is more resticted
Added browse of series in sidebar
Dependencys in vendor folder are updated to newer versions (licencs files are now present)
Bugfix editing Authors names
Made upload on windows working
512 lines
21 KiB
Python
512 lines
21 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
# Copyright 2009 Facebook
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""Translation methods for generating localized strings.
|
|
|
|
To load a locale and generate a translated string::
|
|
|
|
user_locale = tornado.locale.get("es_LA")
|
|
print user_locale.translate("Sign out")
|
|
|
|
`tornado.locale.get()` returns the closest matching locale, not necessarily the
|
|
specific locale you requested. You can support pluralization with
|
|
additional arguments to `~Locale.translate()`, e.g.::
|
|
|
|
people = [...]
|
|
message = user_locale.translate(
|
|
"%(list)s is online", "%(list)s are online", len(people))
|
|
print message % {"list": user_locale.list(people)}
|
|
|
|
The first string is chosen if ``len(people) == 1``, otherwise the second
|
|
string is chosen.
|
|
|
|
Applications should call one of `load_translations` (which uses a simple
|
|
CSV format) or `load_gettext_translations` (which uses the ``.mo`` format
|
|
supported by `gettext` and related tools). If neither method is called,
|
|
the `Locale.translate` method will simply return the original string.
|
|
"""
|
|
|
|
from __future__ import absolute_import, division, print_function, with_statement
|
|
|
|
import csv
|
|
import datetime
|
|
import numbers
|
|
import os
|
|
import re
|
|
|
|
from tornado import escape
|
|
from tornado.log import gen_log
|
|
from tornado.util import u
|
|
|
|
_default_locale = "en_US"
|
|
_translations = {}
|
|
_supported_locales = frozenset([_default_locale])
|
|
_use_gettext = False
|
|
|
|
|
|
def get(*locale_codes):
|
|
"""Returns the closest match for the given locale codes.
|
|
|
|
We iterate over all given locale codes in order. If we have a tight
|
|
or a loose match for the code (e.g., "en" for "en_US"), we return
|
|
the locale. Otherwise we move to the next code in the list.
|
|
|
|
By default we return ``en_US`` if no translations are found for any of
|
|
the specified locales. You can change the default locale with
|
|
`set_default_locale()`.
|
|
"""
|
|
return Locale.get_closest(*locale_codes)
|
|
|
|
|
|
def set_default_locale(code):
|
|
"""Sets the default locale.
|
|
|
|
The default locale is assumed to be the language used for all strings
|
|
in the system. The translations loaded from disk are mappings from
|
|
the default locale to the destination locale. Consequently, you don't
|
|
need to create a translation file for the default locale.
|
|
"""
|
|
global _default_locale
|
|
global _supported_locales
|
|
_default_locale = code
|
|
_supported_locales = frozenset(list(_translations.keys()) + [_default_locale])
|
|
|
|
|
|
def load_translations(directory):
|
|
"""Loads translations from CSV files in a directory.
|
|
|
|
Translations are strings with optional Python-style named placeholders
|
|
(e.g., ``My name is %(name)s``) and their associated translations.
|
|
|
|
The directory should have translation files of the form ``LOCALE.csv``,
|
|
e.g. ``es_GT.csv``. The CSV files should have two or three columns: string,
|
|
translation, and an optional plural indicator. Plural indicators should
|
|
be one of "plural" or "singular". A given string can have both singular
|
|
and plural forms. For example ``%(name)s liked this`` may have a
|
|
different verb conjugation depending on whether %(name)s is one
|
|
name or a list of names. There should be two rows in the CSV file for
|
|
that string, one with plural indicator "singular", and one "plural".
|
|
For strings with no verbs that would change on translation, simply
|
|
use "unknown" or the empty string (or don't include the column at all).
|
|
|
|
The file is read using the `csv` module in the default "excel" dialect.
|
|
In this format there should not be spaces after the commas.
|
|
|
|
Example translation ``es_LA.csv``::
|
|
|
|
"I love you","Te amo"
|
|
"%(name)s liked this","A %(name)s les gustó esto","plural"
|
|
"%(name)s liked this","A %(name)s le gustó esto","singular"
|
|
|
|
"""
|
|
global _translations
|
|
global _supported_locales
|
|
_translations = {}
|
|
for path in os.listdir(directory):
|
|
if not path.endswith(".csv"):
|
|
continue
|
|
locale, extension = path.split(".")
|
|
if not re.match("[a-z]+(_[A-Z]+)?$", locale):
|
|
gen_log.error("Unrecognized locale %r (path: %s)", locale,
|
|
os.path.join(directory, path))
|
|
continue
|
|
full_path = os.path.join(directory, path)
|
|
try:
|
|
# python 3: csv.reader requires a file open in text mode.
|
|
# Force utf8 to avoid dependence on $LANG environment variable.
|
|
f = open(full_path, "r", encoding="utf-8")
|
|
except TypeError:
|
|
# python 2: files return byte strings, which are decoded below.
|
|
f = open(full_path, "r")
|
|
_translations[locale] = {}
|
|
for i, row in enumerate(csv.reader(f)):
|
|
if not row or len(row) < 2:
|
|
continue
|
|
row = [escape.to_unicode(c).strip() for c in row]
|
|
english, translation = row[:2]
|
|
if len(row) > 2:
|
|
plural = row[2] or "unknown"
|
|
else:
|
|
plural = "unknown"
|
|
if plural not in ("plural", "singular", "unknown"):
|
|
gen_log.error("Unrecognized plural indicator %r in %s line %d",
|
|
plural, path, i + 1)
|
|
continue
|
|
_translations[locale].setdefault(plural, {})[english] = translation
|
|
f.close()
|
|
_supported_locales = frozenset(list(_translations.keys()) + [_default_locale])
|
|
gen_log.debug("Supported locales: %s", sorted(_supported_locales))
|
|
|
|
|
|
def load_gettext_translations(directory, domain):
|
|
"""Loads translations from `gettext`'s locale tree
|
|
|
|
Locale tree is similar to system's ``/usr/share/locale``, like::
|
|
|
|
{directory}/{lang}/LC_MESSAGES/{domain}.mo
|
|
|
|
Three steps are required to have you app translated:
|
|
|
|
1. Generate POT translation file::
|
|
|
|
xgettext --language=Python --keyword=_:1,2 -d mydomain file1.py file2.html etc
|
|
|
|
2. Merge against existing POT file::
|
|
|
|
msgmerge old.po mydomain.po > new.po
|
|
|
|
3. Compile::
|
|
|
|
msgfmt mydomain.po -o {directory}/pt_BR/LC_MESSAGES/mydomain.mo
|
|
"""
|
|
import gettext
|
|
global _translations
|
|
global _supported_locales
|
|
global _use_gettext
|
|
_translations = {}
|
|
for lang in os.listdir(directory):
|
|
if lang.startswith('.'):
|
|
continue # skip .svn, etc
|
|
if os.path.isfile(os.path.join(directory, lang)):
|
|
continue
|
|
try:
|
|
os.stat(os.path.join(directory, lang, "LC_MESSAGES", domain + ".mo"))
|
|
_translations[lang] = gettext.translation(domain, directory,
|
|
languages=[lang])
|
|
except Exception as e:
|
|
gen_log.error("Cannot load translation for '%s': %s", lang, str(e))
|
|
continue
|
|
_supported_locales = frozenset(list(_translations.keys()) + [_default_locale])
|
|
_use_gettext = True
|
|
gen_log.debug("Supported locales: %s", sorted(_supported_locales))
|
|
|
|
|
|
def get_supported_locales():
|
|
"""Returns a list of all the supported locale codes."""
|
|
return _supported_locales
|
|
|
|
|
|
class Locale(object):
|
|
"""Object representing a locale.
|
|
|
|
After calling one of `load_translations` or `load_gettext_translations`,
|
|
call `get` or `get_closest` to get a Locale object.
|
|
"""
|
|
@classmethod
|
|
def get_closest(cls, *locale_codes):
|
|
"""Returns the closest match for the given locale code."""
|
|
for code in locale_codes:
|
|
if not code:
|
|
continue
|
|
code = code.replace("-", "_")
|
|
parts = code.split("_")
|
|
if len(parts) > 2:
|
|
continue
|
|
elif len(parts) == 2:
|
|
code = parts[0].lower() + "_" + parts[1].upper()
|
|
if code in _supported_locales:
|
|
return cls.get(code)
|
|
if parts[0].lower() in _supported_locales:
|
|
return cls.get(parts[0].lower())
|
|
return cls.get(_default_locale)
|
|
|
|
@classmethod
|
|
def get(cls, code):
|
|
"""Returns the Locale for the given locale code.
|
|
|
|
If it is not supported, we raise an exception.
|
|
"""
|
|
if not hasattr(cls, "_cache"):
|
|
cls._cache = {}
|
|
if code not in cls._cache:
|
|
assert code in _supported_locales
|
|
translations = _translations.get(code, None)
|
|
if translations is None:
|
|
locale = CSVLocale(code, {})
|
|
elif _use_gettext:
|
|
locale = GettextLocale(code, translations)
|
|
else:
|
|
locale = CSVLocale(code, translations)
|
|
cls._cache[code] = locale
|
|
return cls._cache[code]
|
|
|
|
def __init__(self, code, translations):
|
|
self.code = code
|
|
self.name = LOCALE_NAMES.get(code, {}).get("name", u("Unknown"))
|
|
self.rtl = False
|
|
for prefix in ["fa", "ar", "he"]:
|
|
if self.code.startswith(prefix):
|
|
self.rtl = True
|
|
break
|
|
self.translations = translations
|
|
|
|
# Initialize strings for date formatting
|
|
_ = self.translate
|
|
self._months = [
|
|
_("January"), _("February"), _("March"), _("April"),
|
|
_("May"), _("June"), _("July"), _("August"),
|
|
_("September"), _("October"), _("November"), _("December")]
|
|
self._weekdays = [
|
|
_("Monday"), _("Tuesday"), _("Wednesday"), _("Thursday"),
|
|
_("Friday"), _("Saturday"), _("Sunday")]
|
|
|
|
def translate(self, message, plural_message=None, count=None):
|
|
"""Returns the translation for the given message for this locale.
|
|
|
|
If ``plural_message`` is given, you must also provide
|
|
``count``. We return ``plural_message`` when ``count != 1``,
|
|
and we return the singular form for the given message when
|
|
``count == 1``.
|
|
"""
|
|
raise NotImplementedError()
|
|
|
|
def format_date(self, date, gmt_offset=0, relative=True, shorter=False,
|
|
full_format=False):
|
|
"""Formats the given date (which should be GMT).
|
|
|
|
By default, we return a relative time (e.g., "2 minutes ago"). You
|
|
can return an absolute date string with ``relative=False``.
|
|
|
|
You can force a full format date ("July 10, 1980") with
|
|
``full_format=True``.
|
|
|
|
This method is primarily intended for dates in the past.
|
|
For dates in the future, we fall back to full format.
|
|
"""
|
|
if isinstance(date, numbers.Real):
|
|
date = datetime.datetime.utcfromtimestamp(date)
|
|
now = datetime.datetime.utcnow()
|
|
if date > now:
|
|
if relative and (date - now).seconds < 60:
|
|
# Due to click skew, things are some things slightly
|
|
# in the future. Round timestamps in the immediate
|
|
# future down to now in relative mode.
|
|
date = now
|
|
else:
|
|
# Otherwise, future dates always use the full format.
|
|
full_format = True
|
|
local_date = date - datetime.timedelta(minutes=gmt_offset)
|
|
local_now = now - datetime.timedelta(minutes=gmt_offset)
|
|
local_yesterday = local_now - datetime.timedelta(hours=24)
|
|
difference = now - date
|
|
seconds = difference.seconds
|
|
days = difference.days
|
|
|
|
_ = self.translate
|
|
format = None
|
|
if not full_format:
|
|
if relative and days == 0:
|
|
if seconds < 50:
|
|
return _("1 second ago", "%(seconds)d seconds ago",
|
|
seconds) % {"seconds": seconds}
|
|
|
|
if seconds < 50 * 60:
|
|
minutes = round(seconds / 60.0)
|
|
return _("1 minute ago", "%(minutes)d minutes ago",
|
|
minutes) % {"minutes": minutes}
|
|
|
|
hours = round(seconds / (60.0 * 60))
|
|
return _("1 hour ago", "%(hours)d hours ago",
|
|
hours) % {"hours": hours}
|
|
|
|
if days == 0:
|
|
format = _("%(time)s")
|
|
elif days == 1 and local_date.day == local_yesterday.day and \
|
|
relative:
|
|
format = _("yesterday") if shorter else \
|
|
_("yesterday at %(time)s")
|
|
elif days < 5:
|
|
format = _("%(weekday)s") if shorter else \
|
|
_("%(weekday)s at %(time)s")
|
|
elif days < 334: # 11mo, since confusing for same month last year
|
|
format = _("%(month_name)s %(day)s") if shorter else \
|
|
_("%(month_name)s %(day)s at %(time)s")
|
|
|
|
if format is None:
|
|
format = _("%(month_name)s %(day)s, %(year)s") if shorter else \
|
|
_("%(month_name)s %(day)s, %(year)s at %(time)s")
|
|
|
|
tfhour_clock = self.code not in ("en", "en_US", "zh_CN")
|
|
if tfhour_clock:
|
|
str_time = "%d:%02d" % (local_date.hour, local_date.minute)
|
|
elif self.code == "zh_CN":
|
|
str_time = "%s%d:%02d" % (
|
|
(u('\u4e0a\u5348'), u('\u4e0b\u5348'))[local_date.hour >= 12],
|
|
local_date.hour % 12 or 12, local_date.minute)
|
|
else:
|
|
str_time = "%d:%02d %s" % (
|
|
local_date.hour % 12 or 12, local_date.minute,
|
|
("am", "pm")[local_date.hour >= 12])
|
|
|
|
return format % {
|
|
"month_name": self._months[local_date.month - 1],
|
|
"weekday": self._weekdays[local_date.weekday()],
|
|
"day": str(local_date.day),
|
|
"year": str(local_date.year),
|
|
"time": str_time
|
|
}
|
|
|
|
def format_day(self, date, gmt_offset=0, dow=True):
|
|
"""Formats the given date as a day of week.
|
|
|
|
Example: "Monday, January 22". You can remove the day of week with
|
|
``dow=False``.
|
|
"""
|
|
local_date = date - datetime.timedelta(minutes=gmt_offset)
|
|
_ = self.translate
|
|
if dow:
|
|
return _("%(weekday)s, %(month_name)s %(day)s") % {
|
|
"month_name": self._months[local_date.month - 1],
|
|
"weekday": self._weekdays[local_date.weekday()],
|
|
"day": str(local_date.day),
|
|
}
|
|
else:
|
|
return _("%(month_name)s %(day)s") % {
|
|
"month_name": self._months[local_date.month - 1],
|
|
"day": str(local_date.day),
|
|
}
|
|
|
|
def list(self, parts):
|
|
"""Returns a comma-separated list for the given list of parts.
|
|
|
|
The format is, e.g., "A, B and C", "A and B" or just "A" for lists
|
|
of size 1.
|
|
"""
|
|
_ = self.translate
|
|
if len(parts) == 0:
|
|
return ""
|
|
if len(parts) == 1:
|
|
return parts[0]
|
|
comma = u(' \u0648 ') if self.code.startswith("fa") else u(", ")
|
|
return _("%(commas)s and %(last)s") % {
|
|
"commas": comma.join(parts[:-1]),
|
|
"last": parts[len(parts) - 1],
|
|
}
|
|
|
|
def friendly_number(self, value):
|
|
"""Returns a comma-separated number for the given integer."""
|
|
if self.code not in ("en", "en_US"):
|
|
return str(value)
|
|
value = str(value)
|
|
parts = []
|
|
while value:
|
|
parts.append(value[-3:])
|
|
value = value[:-3]
|
|
return ",".join(reversed(parts))
|
|
|
|
|
|
class CSVLocale(Locale):
|
|
"""Locale implementation using tornado's CSV translation format."""
|
|
def translate(self, message, plural_message=None, count=None):
|
|
if plural_message is not None:
|
|
assert count is not None
|
|
if count != 1:
|
|
message = plural_message
|
|
message_dict = self.translations.get("plural", {})
|
|
else:
|
|
message_dict = self.translations.get("singular", {})
|
|
else:
|
|
message_dict = self.translations.get("unknown", {})
|
|
return message_dict.get(message, message)
|
|
|
|
|
|
class GettextLocale(Locale):
|
|
"""Locale implementation using the `gettext` module."""
|
|
def __init__(self, code, translations):
|
|
try:
|
|
# python 2
|
|
self.ngettext = translations.ungettext
|
|
self.gettext = translations.ugettext
|
|
except AttributeError:
|
|
# python 3
|
|
self.ngettext = translations.ngettext
|
|
self.gettext = translations.gettext
|
|
# self.gettext must exist before __init__ is called, since it
|
|
# calls into self.translate
|
|
super(GettextLocale, self).__init__(code, translations)
|
|
|
|
def translate(self, message, plural_message=None, count=None):
|
|
if plural_message is not None:
|
|
assert count is not None
|
|
return self.ngettext(message, plural_message, count)
|
|
else:
|
|
return self.gettext(message)
|
|
|
|
LOCALE_NAMES = {
|
|
"af_ZA": {"name_en": u("Afrikaans"), "name": u("Afrikaans")},
|
|
"am_ET": {"name_en": u("Amharic"), "name": u('\u12a0\u121b\u122d\u129b')},
|
|
"ar_AR": {"name_en": u("Arabic"), "name": u("\u0627\u0644\u0639\u0631\u0628\u064a\u0629")},
|
|
"bg_BG": {"name_en": u("Bulgarian"), "name": u("\u0411\u044a\u043b\u0433\u0430\u0440\u0441\u043a\u0438")},
|
|
"bn_IN": {"name_en": u("Bengali"), "name": u("\u09ac\u09be\u0982\u09b2\u09be")},
|
|
"bs_BA": {"name_en": u("Bosnian"), "name": u("Bosanski")},
|
|
"ca_ES": {"name_en": u("Catalan"), "name": u("Catal\xe0")},
|
|
"cs_CZ": {"name_en": u("Czech"), "name": u("\u010ce\u0161tina")},
|
|
"cy_GB": {"name_en": u("Welsh"), "name": u("Cymraeg")},
|
|
"da_DK": {"name_en": u("Danish"), "name": u("Dansk")},
|
|
"de_DE": {"name_en": u("German"), "name": u("Deutsch")},
|
|
"el_GR": {"name_en": u("Greek"), "name": u("\u0395\u03bb\u03bb\u03b7\u03bd\u03b9\u03ba\u03ac")},
|
|
"en_GB": {"name_en": u("English (UK)"), "name": u("English (UK)")},
|
|
"en_US": {"name_en": u("English (US)"), "name": u("English (US)")},
|
|
"es_ES": {"name_en": u("Spanish (Spain)"), "name": u("Espa\xf1ol (Espa\xf1a)")},
|
|
"es_LA": {"name_en": u("Spanish"), "name": u("Espa\xf1ol")},
|
|
"et_EE": {"name_en": u("Estonian"), "name": u("Eesti")},
|
|
"eu_ES": {"name_en": u("Basque"), "name": u("Euskara")},
|
|
"fa_IR": {"name_en": u("Persian"), "name": u("\u0641\u0627\u0631\u0633\u06cc")},
|
|
"fi_FI": {"name_en": u("Finnish"), "name": u("Suomi")},
|
|
"fr_CA": {"name_en": u("French (Canada)"), "name": u("Fran\xe7ais (Canada)")},
|
|
"fr_FR": {"name_en": u("French"), "name": u("Fran\xe7ais")},
|
|
"ga_IE": {"name_en": u("Irish"), "name": u("Gaeilge")},
|
|
"gl_ES": {"name_en": u("Galician"), "name": u("Galego")},
|
|
"he_IL": {"name_en": u("Hebrew"), "name": u("\u05e2\u05d1\u05e8\u05d9\u05ea")},
|
|
"hi_IN": {"name_en": u("Hindi"), "name": u("\u0939\u093f\u0928\u094d\u0926\u0940")},
|
|
"hr_HR": {"name_en": u("Croatian"), "name": u("Hrvatski")},
|
|
"hu_HU": {"name_en": u("Hungarian"), "name": u("Magyar")},
|
|
"id_ID": {"name_en": u("Indonesian"), "name": u("Bahasa Indonesia")},
|
|
"is_IS": {"name_en": u("Icelandic"), "name": u("\xcdslenska")},
|
|
"it_IT": {"name_en": u("Italian"), "name": u("Italiano")},
|
|
"ja_JP": {"name_en": u("Japanese"), "name": u("\u65e5\u672c\u8a9e")},
|
|
"ko_KR": {"name_en": u("Korean"), "name": u("\ud55c\uad6d\uc5b4")},
|
|
"lt_LT": {"name_en": u("Lithuanian"), "name": u("Lietuvi\u0173")},
|
|
"lv_LV": {"name_en": u("Latvian"), "name": u("Latvie\u0161u")},
|
|
"mk_MK": {"name_en": u("Macedonian"), "name": u("\u041c\u0430\u043a\u0435\u0434\u043e\u043d\u0441\u043a\u0438")},
|
|
"ml_IN": {"name_en": u("Malayalam"), "name": u("\u0d2e\u0d32\u0d2f\u0d3e\u0d33\u0d02")},
|
|
"ms_MY": {"name_en": u("Malay"), "name": u("Bahasa Melayu")},
|
|
"nb_NO": {"name_en": u("Norwegian (bokmal)"), "name": u("Norsk (bokm\xe5l)")},
|
|
"nl_NL": {"name_en": u("Dutch"), "name": u("Nederlands")},
|
|
"nn_NO": {"name_en": u("Norwegian (nynorsk)"), "name": u("Norsk (nynorsk)")},
|
|
"pa_IN": {"name_en": u("Punjabi"), "name": u("\u0a2a\u0a70\u0a1c\u0a3e\u0a2c\u0a40")},
|
|
"pl_PL": {"name_en": u("Polish"), "name": u("Polski")},
|
|
"pt_BR": {"name_en": u("Portuguese (Brazil)"), "name": u("Portugu\xeas (Brasil)")},
|
|
"pt_PT": {"name_en": u("Portuguese (Portugal)"), "name": u("Portugu\xeas (Portugal)")},
|
|
"ro_RO": {"name_en": u("Romanian"), "name": u("Rom\xe2n\u0103")},
|
|
"ru_RU": {"name_en": u("Russian"), "name": u("\u0420\u0443\u0441\u0441\u043a\u0438\u0439")},
|
|
"sk_SK": {"name_en": u("Slovak"), "name": u("Sloven\u010dina")},
|
|
"sl_SI": {"name_en": u("Slovenian"), "name": u("Sloven\u0161\u010dina")},
|
|
"sq_AL": {"name_en": u("Albanian"), "name": u("Shqip")},
|
|
"sr_RS": {"name_en": u("Serbian"), "name": u("\u0421\u0440\u043f\u0441\u043a\u0438")},
|
|
"sv_SE": {"name_en": u("Swedish"), "name": u("Svenska")},
|
|
"sw_KE": {"name_en": u("Swahili"), "name": u("Kiswahili")},
|
|
"ta_IN": {"name_en": u("Tamil"), "name": u("\u0ba4\u0bae\u0bbf\u0bb4\u0bcd")},
|
|
"te_IN": {"name_en": u("Telugu"), "name": u("\u0c24\u0c46\u0c32\u0c41\u0c17\u0c41")},
|
|
"th_TH": {"name_en": u("Thai"), "name": u("\u0e20\u0e32\u0e29\u0e32\u0e44\u0e17\u0e22")},
|
|
"tl_PH": {"name_en": u("Filipino"), "name": u("Filipino")},
|
|
"tr_TR": {"name_en": u("Turkish"), "name": u("T\xfcrk\xe7e")},
|
|
"uk_UA": {"name_en": u("Ukraini "), "name": u("\u0423\u043a\u0440\u0430\u0457\u043d\u0441\u044c\u043a\u0430")},
|
|
"vi_VN": {"name_en": u("Vietnamese"), "name": u("Ti\u1ebfng Vi\u1ec7t")},
|
|
"zh_CN": {"name_en": u("Chinese (Simplified)"), "name": u("\u4e2d\u6587(\u7b80\u4f53)")},
|
|
"zh_TW": {"name_en": u("Chinese (Traditional)"), "name": u("\u4e2d\u6587(\u7e41\u9ad4)")},
|
|
}
|