Python babel 模块，Locale() 实例源码

def test_serialize_value(self):
        now = datetime.datetime.now()
        self.assertEqual(now.isoformat(), fields.serialize_value(now))
        unique_id = uuid.uuid4()
        self.assertEqual(str(unique_id), fields.serialize_value(unique_id))
        self.assertEqual(
            {"now": now.isoformat()},
            fields.serialize_value({"now": now})
        )
        self.assertEqual(
            "Europe/Paris",
            fields.serialize_value(timezone("Europe/Paris"))
        )
        self.assertEqual(
            "en_US",
            fields.serialize_value(Locale("en_US"))
        )

def cast_locale(obj, locale):
    """
    Cast given locale to string. Supports also callbacks that return locales.

    :param obj:
        Object or class to use as a possible parameter to locale callable
    :param locale:
        Locale object or string or callable that returns a locale.
    """
    if callable(locale):
        try:
            locale = locale()
        except TypeError:
            locale = locale(obj)
    if isinstance(locale, babel.Locale):
        return str(locale)
    return locale

def new_lang_view(self):

        lang = self.request.POST.get('new_lang', '').strip()
        try:
            self.request.locale = babel.Locale(*babel.parse_locale(lang))

            if not os.path.isdir(os.path.join(self.helper.locale_dir, lang)):
                os.mkdir(os.path.join(self.helper.locale_dir, lang))
                os.mkdir(os.path.join(self.helper._dir, 'locale', lang, 'LC_MESSAGES'))
                # self.pot.save(os.path.join(self.helper.package_dir, 'locale', lang, 'LC_MESSAGES',
                #                            '{0}.po'.format(self.domain)))
                # self.pot.save_as_mofile(os.path.join(self.helper.package_dir, 'locale', lang, 'LC_MESSAGES',
                #                                      '{0}.mo'.format(self.domain)))

                self.request.flash_message.add(message_type='success', body='i18n_new_lang_creation_success', domain='i18n_helper')

                return HTTPFound(location=self.request.route_url('i18n_helper.po', lang=lang, domain=self.domain))

            else:
                self.request.flash_message.add(message_type='danger', body='i18n_new_lang_lang_exist', domain='i18n_helper')

        except:
            self.request.flash_message.add(message_type='danger', body='i18n_new_lang_creation_error', domain='i18n_helper')

        return self.get_view()

def __init__(self, context, request: Request):
        self.request = request
        self.context = context
        _ = request.translate
        self.helper = request.registry['i18n_helper']
        self.lang = request.matchdict['lang']
        self.domain = request.matchdict['domain']

        self.locale = babel.Locale(*babel.parse_locale(self.lang))

        self.pot_file_path = os.path.join(self.helper.locale_dir, '{0}.pot'.format(self.domain))
        self.po_file_path = os.path.join(self.helper.locale_dir, self.lang, 'LC_MESSAGES',
                                         '{0}.po'.format(self.domain))
        self.mo_file_path = os.path.join(self.helper.locale_dir, self.lang, 'LC_MESSAGES',
                                         '{0}.mo'.format(self.domain))

        if os.path.exists(self.po_file_path):
            self.po = polib.pofile(self.po_file_path, encoding='UTF-8')
        else:
            self.po = polib.POFile(encoding='UTF-8')

        self.po.metadata= {'Content-Transfer-Encoding': '8bit',
                           'Content-Type': 'text/plain; charset=UTF-8',
                           'Language': self.lang}

def add_localizer(event):
    request = event.request
    localizer = request.localizer
    helper = request.registry['i18n_helper']
    collect_msgid = asbool(request.registry.settings.get('i18n_helper.collect_msgid'))

    def auto_translate(string, mapping=None, domain=None):
        if collect_msgid:
            tmp = domain if domain else helper.package_name

            if not tmp in helper.pot_msgids:
                helper.pot_msgids[tmp] = set()

            helper.pot_msgids[tmp].add(string)

        return localizer.translate(helper.tsf(string), mapping=mapping, domain=domain)

    # request.localizer = localizer
    request.translate = auto_translate
    request.locale = babel.Locale(*babel.parse_locale(request.localizer.locale_name))

def localized_measures():
    print('Localized measurement units')
    units = (
        'area-square-meter',
        'consumption-liter-per-100kilometers',
        'pressure-hectopascal',
        'duration-century',
        'energy-kilowatt-hour',
        'volume-pint',
    )
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        args = [name]
        for unit in units:
            unit_name = get_unit_name(unit, locale=locale)
            if unit_name is None:
                unit_name = 'N/A ({0})'.format(unit)
            args.append(unit_name)
        print('\nin {0}: {1} - {2} - {3} - {4} - {5} - {6}'.format(*args))

def units_formating():
    print('Formating values in units')
    values = (
        (12.4, 'area-square-meter'),
        (7.7, 'consumption-liter-per-100kilometers'),
        (1017, 'pressure-hectopascal'),
        (9, 'duration-century'),
        (11, 'energy-kilowatt-hour'),
        (2, 'volume-pint'),
    )
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        args = [name]
        for (value, unit) in values:
            val_long = format_unit(value, unit, 'long', locale=locale)
            short_name = get_unit_name(unit, 'short', locale=locale) 
            args.append('{0} ({1})'.format(val_long, short_name))
        print('\nin {0}: {1} - {2} - {3} - {4} - {5} - {6}'.format(*args))

def time_deltas():
    print('Periods of time (timedelta)')
    deltas = (
        datetime.timedelta(minutes=15),
        datetime.timedelta(hours=3),
        datetime.timedelta(days=8),
        datetime.timedelta(weeks=5),
    )
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        args = [name]
        for delta in deltas:
            args.append(format_timedelta(delta, locale=locale))
        print('\tbasic {0}: {1} - {2} - {3} - {4}'.format(*args))
        args = [name]
        for delta in deltas:
            args.append(format_timedelta(delta, granularity='day', locale=locale))
        print('\tday granularity {0}: {1} - {2} - {3} - {4}'.format(*args))

def test_url_for_with_locale_object(self):
        url = '/foo/de/dataset/my_dataset'
        generated_url = h.url_for('/dataset/my_dataset',
                                  locale=Locale('de'))
        eq_(generated_url, url)

def serialize_value(value):
    """
    Utility function to handle the parsing of specific fields.
    """
    if isinstance(value, datetime.datetime):
        return value.isoformat()
    if isinstance(value, datetime.date):
        return value.isoformat()
    elif isinstance(value, uuid.UUID):
        return str(value)
    elif isinstance(value, dict):
        return serialize_dict(value)
    elif isinstance(value, orm.collections.InstrumentedList):
        return serialize_orm_arrays(value)
    elif isinstance(value, bytes):
        return value.decode("utf-8")
    elif isinstance(value, str):
        return value
    elif isinstance(value, int):
        return value
    elif isinstance(value, Locale):
        return str(value)
    elif isinstance(value, type(timezone("Europe/Paris"))):
        return str(value)
    elif isinstance(value, list):
        return serialize_list(value)
    elif value is None:
        return None
    elif isinstance(value, object):
        if hasattr(value, 'serialize'):
            return value.serialize()
        else:
            return value
    else:
        return value

def __init__(self, locale='en_GB'):
        self.locale = Locale(locale)

def process_bind_param(self, value, dialect):
        if isinstance(value, babel.Locale):
            return six.text_type(value)

        if isinstance(value, six.string_types):
            return value

def process_result_value(self, value, dialect):
        if value is not None:
            return babel.Locale.parse(value)

def _coerce(self, value):
        if value is not None and not isinstance(value, babel.Locale):
            return babel.Locale.parse(value)
        return value

def validate(self, code):
        try:
            i18n.babel.Locale('en').currencies[code]
        except KeyError:
            raise ValueError("'{0}' is not valid currency code.".format(code))

def select_lang_view(self):


        lang = self.request.POST.get('select_lang', '').strip()

        self.request.locale = babel.Locale(*babel.parse_locale(lang))


        return HTTPFound(location=self.request.route_url('i18n_helper.po', lang=lang, domain=self.domain))

def list_format():
    print('Formating lists')
    items = (
        'one',
        'two',
        'three',
        'four',
        'five'
    )
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        result = format_list(items, locale=locale)
        print('\tlist in {0} - {1}'.format(name, result))

def format_class():
    print('Utility class that holds all formating functionality for single locale')
    date = datetime.date(1874, 5, 29)
    amount = (284.55, 'CNY')
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        fmt = Format(locale=locale)
        args = [name]
        args.append(fmt.date(date, format='full'))
        args.append(fmt.currency(*amount))
        print('\tFormats for {0} - date: {1}, currency: {2}'.format(*args))

def languages():
    print('Known languages')
    locale = Locale('en', 'US')
    for (_, _, params) in LOCALES:
        territory = params[1]
        official_languages = format_list(get_official_languages(territory), locale=locale)
        all_languages = format_list(get_official_languages(territory, regional=True, de_facto=True), locale=locale)
        print('\tterritory: {0}'.format(locale.territories[territory]))
        print('\t\tofficial: {0}\n\t\tall: {1}'.format(official_languages, all_languages))

def my_birthday():
    print('My birthday in different locales')
    bday = datetime.date(1971, 5, 4)
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        for fmt in ('full', 'medium', 'short'):
            print('\t{0} ({1}): {2}'.format(name, fmt, format_date(bday, fmt, locale)))

def timezone_names():
    print('Timezone data')
    tznames = ('Europe/Athens', 'US/Alaska', 'Africa/Johannesburg')
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        for tzname in tznames:
            tz = get_timezone(tzname)
            loc_name = get_timezone_location(tz, locale, False)
            city = get_timezone_location(tz, locale, True)
            print('\tTZ location for {0}: {1}, city: {2}'.format(tzname, loc_name, city))

def locale_own_data():
    print('Locale data (pl - language only):')
    locale = Locale('pl')
    print('\tDisplay name: {0}'.format(locale.display_name))
    print('\tEnglish name: {0}'.format(locale.english_name))
    print('Locale data (pl_PL - language and territory):')
    locale = Locale('pl', 'PL')
    print('\tDisplay name: {0}'.format(locale.display_name))
    print('\tEnglish name: {0}'.format(locale.english_name))

def localized_locale_data():
    print('Localized locale data')
    for (name, symbol, params) in LOCALES:
        print('Now switch to {0} ({1})'.format(name, symbol))
        locale = Locale(*params)
        print('\tLocale display name: {0}'.format(locale.display_name))
        print('\tLocale English name: {0}'.format(locale.english_name))
        print('\tPoland (localized): {0}'.format(locale.territories['PL']))
        print('\tRomanian New Lei (localized): {0}'.format(locale.currencies['RON']))
        print('\tRomanian Old Lei (localized): {0}'.format(locale.currencies['ROL']))
        print('\t1st weekday (localized): {0}'.format(locale.days['format']['wide'][locale.first_week_day]))
        print('\tMay month name (localized): {0}'.format(locale.months['format']['wide'][5]))

def decimal_formating():
    print('Formating decimal values')
    numbers = (-3.14, 0.12, 2, 9.821, 215.3, 19678.25)
    for (name, symbol, params) in LOCALES:
        locale = Locale(*params)
        args = [name]
        for num in numbers:
            args.append(format_decimal(num, locale=locale))
        print('\tdecimal in {0}: {1} - {2} - {3} - {4} - {5} - {6}'.format(*args))

def __init__(self, context, request: Request):
        self.request = request
        self.context = context
        self.domain = request.matchdict['domain']
        _ = request.translate

        self.helper = request.registry['i18n_helper']

        self.pot = polib.pofile(
            os.path.join(self.helper.locale_dir, '{0}.pot'.format(self.domain)),
            encoding='UTF-8'
        )



        # LANG FORM
        langs_dir = self.helper.locale_dir
        created_langs_choices = []
        for lang in os.listdir(langs_dir):
            if os.path.isdir(os.path.join(langs_dir, lang)):
                lang_locale = babel.Locale(*babel.parse_locale(lang))
                created_langs_choices.append(
                    (lang , '{en_name}/{display_name}'.format(
                        en_name=lang_locale.english_name,
                        display_name=lang_locale.display_name )
                    )
                )

        available_langs_choices = sorted(locale.locale_alias)

        class NewLang(colander.Schema):
            new_lang = colander.SchemaNode(colander.String(),
                                           widget=deform.widget.AutocompleteInputWidget(values=available_langs_choices,
                                                                                        min_length=0),
                                           title=_("i18n_new_lang", domain='i18n_helper'))

        class SelectLang(colander.Schema):
            select_lang = colander.SchemaNode(colander.String(),
                                           widget=deform.widget.SelectWidget(values=created_langs_choices),
                                           title=_("i18n_select_lang", domain='i18n_helper'))

        def validator(node, appstruct):
            return True

        schema = NewLang(validator=validator)
        schema = schema.bind(request=self.request)
        self.new_lang_form = deform.Form(schema,
                                         use_ajax=False,
                                         action=self.request.route_url('i18n_helper.pot', domain=self.domain))
        self.new_lang_form.buttons.append(deform.Button(name='submit', title=_('i18n_new_lang_submit', domain='i18n_helper')))

        schema = SelectLang(validator=validator)
        schema = schema.bind(request=self.request)
        self.select_lang_form = deform.Form(schema,
                                            use_ajax=False,
                                            action=self.request.route_url('i18n_helper.pot', domain=self.domain))
        self.select_lang_form.buttons.append(deform.Button(name='submit', title=_('i18n_select_lang_submit', domain='i18n_helper')))

        # MSG FORM