raise LookupError(f"Unknown timezone {zone}") from exc
-def get_period_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
- context: _Context = 'stand-alone', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+def get_period_names(
+ width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+ context: _Context = 'stand-alone',
+ locale: Locale | str | None = None,
+) -> LocaleDataDict:
"""Return the names for day periods (AM/PM) used by the locale.
>>> get_period_names(locale='en_US')['am']
:param width: the width to use, one of "abbreviated", "narrow", or "wide"
:param context: the context, either "format" or "stand-alone"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).day_periods[context][width]
+ return Locale.parse(locale or LC_TIME).day_periods[context][width]
-def get_day_names(width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
- context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+def get_day_names(
+ width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
+ context: _Context = 'format',
+ locale: Locale | str | None = None,
+) -> LocaleDataDict:
"""Return the day names used by the locale for the specified format.
>>> get_day_names('wide', locale='en_US')[1]
:param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
:param context: the context, either "format" or "stand-alone"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).days[context][width]
+ return Locale.parse(locale or LC_TIME).days[context][width]
-def get_month_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
- context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+def get_month_names(
+ width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+ context: _Context = 'format',
+ locale: Locale | str | None = None,
+) -> LocaleDataDict:
"""Return the month names used by the locale for the specified format.
>>> get_month_names('wide', locale='en_US')[1]
:param width: the width to use, one of "wide", "abbreviated", or "narrow"
:param context: the context, either "format" or "stand-alone"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).months[context][width]
+ return Locale.parse(locale or LC_TIME).months[context][width]
-def get_quarter_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
- context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+def get_quarter_names(
+ width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+ context: _Context = 'format',
+ locale: Locale | str | None = None,
+) -> LocaleDataDict:
"""Return the quarter names used by the locale for the specified format.
>>> get_quarter_names('wide', locale='en_US')[1]
:param width: the width to use, one of "wide", "abbreviated", or "narrow"
:param context: the context, either "format" or "stand-alone"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).quarters[context][width]
+ return Locale.parse(locale or LC_TIME).quarters[context][width]
-def get_era_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
- locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+def get_era_names(
+ width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+ locale: Locale | str | None = None,
+) -> LocaleDataDict:
"""Return the era names used by the locale for the specified format.
>>> get_era_names('wide', locale='en_US')[1]
u'n. Chr.'
:param width: the width to use, either "wide", "abbreviated", or "narrow"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).eras[width]
+ return Locale.parse(locale or LC_TIME).eras[width]
-def get_date_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
+def get_date_format(
+ format: _PredefinedTimeFormat = 'medium',
+ locale: Locale | str | None = None,
+) -> DateTimePattern:
"""Return the date formatting patterns used by the locale for the specified
format.
:param format: the format to use, one of "full", "long", "medium", or
"short"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).date_formats[format]
+ return Locale.parse(locale or LC_TIME).date_formats[format]
-def get_datetime_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
+def get_datetime_format(
+ format: _PredefinedTimeFormat = 'medium',
+ locale: Locale | str | None = None,
+) -> DateTimePattern:
"""Return the datetime formatting patterns used by the locale for the
specified format.
:param format: the format to use, one of "full", "long", "medium", or
"short"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- patterns = Locale.parse(locale).datetime_formats
+ patterns = Locale.parse(locale or LC_TIME).datetime_formats
if format not in patterns:
format = None
return patterns[format]
-def get_time_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
+def get_time_format(
+ format: _PredefinedTimeFormat = 'medium',
+ locale: Locale | str | None = None,
+) -> DateTimePattern:
"""Return the time formatting patterns used by the locale for the specified
format.
:param format: the format to use, one of "full", "long", "medium", or
"short"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
"""
- return Locale.parse(locale).time_formats[format]
+ return Locale.parse(locale or LC_TIME).time_formats[format]
def get_timezone_gmt(
datetime: _Instant = None,
width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
return_z: bool = False,
) -> str:
"""Return the timezone associated with the given `datetime` object formatted
:param datetime: the ``datetime`` object; if `None`, the current date and
time in UTC is used
:param width: either "long" or "short" or "iso8601" or "iso8601_short"
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
:param return_z: True or False; Function returns indicator "Z"
when local time offset is 0
"""
datetime = _ensure_datetime_tzinfo(_get_datetime(datetime))
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
offset = datetime.tzinfo.utcoffset(datetime)
seconds = offset.days * 24 * 60 * 60 + offset.seconds
def get_timezone_location(
dt_or_tzinfo: _DtOrTzinfo = None,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
return_city: bool = False,
) -> str:
"""Return a representation of the given timezone using "location format".
:param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
the timezone; if `None`, the current date and time in
UTC is assumed
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
:param return_city: True or False, if True then return exemplar city (location)
for the time zone
:return: the localized timezone name using location format
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
zone = _get_tz_name(dt_or_tzinfo)
dt_or_tzinfo: _DtOrTzinfo = None,
width: Literal['long', 'short'] = 'long',
uncommon: bool = False,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
zone_variant: Literal['generic', 'daylight', 'standard'] | None = None,
return_zone: bool = False,
) -> str:
``'generic'`` variation is assumed. The following
values are valid: ``'generic'``, ``'daylight'`` and
``'standard'``.
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
:param return_zone: True or False. If true then function
returns long time zone ID
"""
dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
zone = _get_tz_name(dt_or_tzinfo)
def format_date(
date: datetime.date | None = None,
format: _PredefinedTimeFormat | str = 'medium',
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
) -> str:
"""Return a date formatted according to the given pattern.
date is used
:param format: one of "full", "long", "medium", or "short", or a custom
date/time pattern
- :param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
"""
if date is None:
date = datetime.date.today()
elif isinstance(date, datetime.datetime):
date = date.date()
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
if format in ('full', 'long', 'medium', 'short'):
format = get_date_format(format, locale=locale)
pattern = parse_pattern(format)
datetime: _Instant = None,
format: _PredefinedTimeFormat | str = 'medium',
tzinfo: datetime.tzinfo | None = None,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
) -> str:
r"""Return a date formatted according to the given pattern.
:param format: one of "full", "long", "medium", or "short", or a custom
date/time pattern
:param tzinfo: the timezone to apply to the time for display
- :param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
"""
datetime = _ensure_datetime_tzinfo(_get_datetime(datetime), tzinfo)
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
if format in ('full', 'long', 'medium', 'short'):
return get_datetime_format(format, locale=locale) \
.replace("'", "") \
def format_time(
time: datetime.time | datetime.datetime | float | None = None,
format: _PredefinedTimeFormat | str = 'medium',
- tzinfo: datetime.tzinfo | None = None, locale: Locale | str | None = LC_TIME,
+ tzinfo: datetime.tzinfo | None = None,
+ locale: Locale | str | None = None,
) -> str:
r"""Return a time formatted according to the given pattern.
:param format: one of "full", "long", "medium", or "short", or a custom
date/time pattern
:param tzinfo: the time-zone to apply to the time for display
- :param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
"""
# get reference date for if we need to find the right timezone variant
time = _get_time(time, tzinfo)
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
if format in ('full', 'long', 'medium', 'short'):
format = get_time_format(format, locale=locale)
return parse_pattern(format).apply(time, locale, reference_date=ref_date)
datetime: _Instant = None,
tzinfo: datetime.tzinfo | None = None,
fuzzy: bool = True,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
) -> str:
r"""Return a time and/or date formatted according to the given pattern.
:param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
close enough to it. If there is no close match, a `KeyError`
is thrown.
- :param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
if fuzzy and skeleton not in locale.datetime_skeletons:
skeleton = match_skeleton(skeleton, locale.datetime_skeletons)
format = locale.datetime_skeletons[skeleton]
threshold: float = .85,
add_direction: bool = False,
format: Literal['narrow', 'short', 'medium', 'long'] = 'long',
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
) -> str:
"""Return a time delta according to the rules of the given locale.
:param format: the format, can be "narrow", "short" or "long". (
"medium" is deprecated, currently converted to "long" to
maintain compatibility)
- :param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
"""
if format not in ('narrow', 'short', 'medium', 'long'):
raise TypeError('Format must be one of "narrow", "short" or "long"')
seconds = int((delta.days * 86400) + delta.seconds)
else:
seconds = delta
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
date_fields = locale._data["date_fields"]
unit_patterns = locale._data["unit_patterns"]
end: _Instant,
skeleton: str | None,
tzinfo: datetime.tzinfo | None,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale,
) -> str:
if skeleton in locale.datetime_skeletons: # Use the given skeleton
format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
skeleton: str | None = None,
tzinfo: datetime.tzinfo | None = None,
fuzzy: bool = True,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
) -> str:
"""
Format an interval between two instants according to the locale's rules.
:param tzinfo: tzinfo to use (if none is already attached)
:param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
close enough to it.
- :param locale: A locale object or identifier.
+ :param locale: A locale object or identifier. Defaults to the system time locale.
:return: Formatted interval
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
# NB: The quote comments below are from the algorithm description in
# https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
time: _Instant,
tzinfo: datetime.tzinfo | None = None,
type: Literal['selection'] | None = None,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
) -> str:
"""
Get the day period ID for a given time.
:param type: The period type to use. Either "selection" or None.
The selection type is used for selecting among phrases such as
“Your email arrived yesterday evening” or “Your email arrived last night”.
- :param locale: the `Locale` object, or a locale string
+ :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
:return: period ID. Something is always returned -- even if it's just "am" or "pm".
"""
time = _get_time(time, tzinfo)
seconds_past_midnight = int(time.hour * 60 * 60 + time.minute * 60 + time.second)
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_TIME)
# The LDML rules state that the rules may not overlap, so iterating in arbitrary
# order should be alright, though `at` periods should be preferred.
def parse_date(
string: str,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
format: _PredefinedTimeFormat | str = 'medium',
) -> datetime.date:
"""Parse a date from a string.
:param string: the string containing the date
:param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
:param format: the format to use, either an explicit date format,
or one of "full", "long", "medium", or "short"
(see ``get_time_format``)
def parse_time(
string: str,
- locale: Locale | str | None = LC_TIME,
+ locale: Locale | str | None = None,
format: _PredefinedTimeFormat | str = 'medium',
) -> datetime.time:
"""Parse a time from a string.
datetime.time(15, 30)
:param string: the string containing the time
- :param locale: a `Locale` object or a locale identifier
+ :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
:param format: the format to use, either an explicit time format,
or one of "full", "long", "medium", or "short"
(see ``get_time_format``)
def format_list(
lst: Sequence[str],
style: Literal['standard', 'standard-short', 'or', 'or-short', 'unit', 'unit-short', 'unit-narrow'] = 'standard',
- locale: Locale | str | None = DEFAULT_LOCALE,
+ locale: Locale | str | None = None,
) -> str:
"""
Format the items in `lst` as a list.
:param lst: a sequence of items to format in to a list
:param style: the style to format the list with. See above for description.
- :param locale: the locale
+ :param locale: the locale. Defaults to the system locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or DEFAULT_LOCALE)
if not lst:
return ''
if len(lst) == 1:
return self.plural_forms
-def get_plural(locale: str | None = LC_CTYPE) -> _PluralTuple:
+def get_plural(locale: str | None = None) -> _PluralTuple:
"""A tuple with the information catalogs need to perform proper
pluralization. The first item of the tuple is the number of plural
forms, the second the plural expression.
+ :param locale: the `Locale` object or locale identifier. Defaults to the system character type locale.
+
>>> get_plural(locale='en')
(2, '(n != 1)')
>>> get_plural(locale='ga')
>>> str(tup)
'nplurals=1; plural=0;'
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_CTYPE)
try:
tup = PLURALS[str(locale)]
except KeyError:
def get_currency_name(
currency: str,
count: float | decimal.Decimal | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
) -> str:
"""Return the name used by the locale for the specified currency.
:param currency: the currency code.
:param count: the optional count. If provided the currency name
will be pluralized to that number if possible.
- :param locale: the `Locale` object or locale identifier.
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
"""
- loc = Locale.parse(locale)
+ loc = Locale.parse(locale or LC_NUMERIC)
if count is not None:
try:
plural_form = loc.plural_form(count)
return loc.currencies.get(currency, currency)
-def get_currency_symbol(currency: str, locale: Locale | str | None = LC_NUMERIC) -> str:
+def get_currency_symbol(currency: str, locale: Locale | str | None = None) -> str:
"""Return the symbol used by the locale for the specified currency.
>>> get_currency_symbol('USD', locale='en_US')
u'$'
:param currency: the currency code.
- :param locale: the `Locale` object or locale identifier.
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
"""
- return Locale.parse(locale).currency_symbols.get(currency, currency)
+ return Locale.parse(locale or LC_NUMERIC).currency_symbols.get(currency, currency)
def get_currency_precision(currency: str) -> int:
def get_currency_unit_pattern(
currency: str,
count: float | decimal.Decimal | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
) -> str:
"""
Return the unit pattern used for long display of a currency value
:param currency: the currency code.
:param count: the optional count. If provided the unit
pattern for that number will be returned.
- :param locale: the `Locale` object or locale identifier.
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
"""
- loc = Locale.parse(locale)
+ loc = Locale.parse(locale or LC_NUMERIC)
if count is not None:
plural_form = loc.plural_form(count)
try:
def _get_number_symbols(
- locale: Locale | str | None,
+ locale: Locale,
*,
numbering_system: Literal["default"] | str = "latn",
) -> LocaleDataDict:
- parsed_locale = Locale.parse(locale)
- numbering_system = _get_numbering_system(parsed_locale, numbering_system)
+ numbering_system = _get_numbering_system(locale, numbering_system)
try:
- return parsed_locale.number_symbols[numbering_system]
+ return locale.number_symbols[numbering_system]
except KeyError as error:
- raise UnsupportedNumberingSystemError(f"Unknown numbering system {numbering_system} for Locale {parsed_locale}.") from error
+ raise UnsupportedNumberingSystemError(f"Unknown numbering system {numbering_system} for Locale {locale}.") from error
class UnsupportedNumberingSystemError(Exception):
def get_decimal_symbol(
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
>>> get_decimal_symbol('ar_EG', numbering_system='latn')
u'.'
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
return _get_number_symbols(locale, numbering_system=numbering_system).get('decimal', '.')
def get_plus_sign_symbol(
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
>>> get_plus_sign_symbol('ar_EG', numbering_system='latn')
u'\u200e+'
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
return _get_number_symbols(locale, numbering_system=numbering_system).get('plusSign', '+')
def get_minus_sign_symbol(
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
>>> get_minus_sign_symbol('ar_EG', numbering_system='latn')
u'\u200e-'
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
return _get_number_symbols(locale, numbering_system=numbering_system).get('minusSign', '-')
def get_exponential_symbol(
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
>>> get_exponential_symbol('ar_EG', numbering_system='latn')
u'E'
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
return _get_number_symbols(locale, numbering_system=numbering_system).get('exponential', 'E')
def get_group_symbol(
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
>>> get_group_symbol('ar_EG', numbering_system='latn')
u','
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
return _get_number_symbols(locale, numbering_system=numbering_system).get('group', ',')
def get_infinity_symbol(
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
>>> get_infinity_symbol('ar_EG', numbering_system='latn')
u'∞'
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
return _get_number_symbols(locale, numbering_system=numbering_system).get('infinity', '∞')
-def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = LC_NUMERIC) -> str:
+def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = None) -> str:
"""Return the given number formatted for a specific locale.
>>> format_number(1099, locale='en_US') # doctest: +SKIP
Use babel.numbers.format_decimal() instead.
:param number: the number to format
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
"""
def format_decimal(
number: float | decimal.Decimal | str,
format: str | NumberPattern | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
decimal_quantization: bool = True,
group_separator: bool = True,
*,
:param number: the number to format
:param format:
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param decimal_quantization: Truncate and round high-precision numbers to
the format pattern. Defaults to `True`.
:param group_separator: Boolean to switch group separator on/off in a locale's
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
if format is None:
format = locale.decimal_formats[format]
pattern = parse_pattern(format)
number: float | decimal.Decimal | str,
*,
format_type: Literal["short", "long"] = "short",
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
fraction_digits: int = 0,
numbering_system: Literal["default"] | str = "latn",
) -> str:
:param number: the number to format
:param format_type: Compact format to use ("short" or "long")
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
compact_format = locale.compact_decimal_formats[format_type]
number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
# Did not find a format, fall back.
number: float | decimal.Decimal | str,
currency: str,
format: str | NumberPattern | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
currency_digits: bool = True,
format_type: Literal["name", "standard", "accounting"] = "standard",
decimal_quantization: bool = True,
:param number: the number to format
:param currency: the currency code
:param format: the format string to use
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param currency_digits: use the currency's natural number of decimal digits
:param format_type: the currency format type to use
:param decimal_quantization: Truncate and round high-precision numbers to
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
+ locale = Locale.parse(locale or LC_NUMERIC)
+
if format_type == 'name':
return _format_currency_long_name(
number,
numbering_system=numbering_system,
)
- locale = Locale.parse(locale)
if format:
pattern = parse_pattern(format)
else:
number: float | decimal.Decimal | str,
currency: str,
*,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale,
format: str | NumberPattern | None,
currency_digits: bool,
decimal_quantization: bool,
) -> str:
# Algorithm described here:
# https://www.unicode.org/reports/tr35/tr35-numbers.html#Currencies
- locale = Locale.parse(locale)
+
# Step 1.
# There are no examples of items with explicit count (0 or 1) in current
# locale data. So there is no point implementing that.
currency: str,
*,
format_type: Literal["short"] = "short",
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
fraction_digits: int = 0,
numbering_system: Literal["default"] | str = "latn",
) -> str:
:param number: the number to format
:param currency: the currency code
:param format_type: the compact format type to use. Defaults to "short".
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
try:
compact_format = locale.compact_currency_formats[format_type]
except KeyError as error:
def format_percent(
number: float | decimal.Decimal | str,
format: str | NumberPattern | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
decimal_quantization: bool = True,
group_separator: bool = True,
*,
:param number: the percent number to format
:param format:
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param decimal_quantization: Truncate and round high-precision numbers to
the format pattern. Defaults to `True`.
:param group_separator: Boolean to switch group separator on/off in a locale's
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
if not format:
format = locale.percent_formats[None]
pattern = parse_pattern(format)
def format_scientific(
- number: float | decimal.Decimal | str,
- format: str | NumberPattern | None = None,
- locale: Locale | str | None = LC_NUMERIC,
- decimal_quantization: bool = True,
- *,
- numbering_system: Literal["default"] | str = "latn",
+ number: float | decimal.Decimal | str,
+ format: str | NumberPattern | None = None,
+ locale: Locale | str | None = None,
+ decimal_quantization: bool = True,
+ *,
+ numbering_system: Literal["default"] | str = "latn",
) -> str:
"""Return value formatted in scientific notation for a specific locale.
:param number: the number to format
:param format:
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param decimal_quantization: Truncate and round high-precision numbers to
the format pattern. Defaults to `True`.
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
if not format:
format = locale.scientific_formats[None]
pattern = parse_pattern(format)
def parse_number(
string: str,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> int:
NumberFormatError: '1.099,98' is not a valid number
:param string: the string to parse
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:return: the parsed number
def parse_decimal(
string: str,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
strict: bool = False,
*,
numbering_system: Literal["default"] | str = "latn",
NumberFormatError: '0.00' is not a properly formatted decimal number. Did you mean '0'?
:param string: the string to parse
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param strict: controls whether numbers formatted in a weird way are
accepted or rejected
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
decimal number
:raise UnsupportedNumberingSystemError: if the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
decimal_symbol = get_decimal_symbol(locale, numbering_system=numbering_system)
def get_unit_name(
measurement_unit: str,
length: Literal['short', 'long', 'narrow'] = 'long',
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
) -> str | None:
"""
Get the display name for a measurement unit in the given locale.
https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
:param length: "short", "long" or "narrow"
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:return: The unit display name, or None.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
unit = _find_unit_pattern(measurement_unit, locale=locale)
if not unit:
raise UnknownUnitError(unit=measurement_unit, locale=locale)
return locale.unit_display_names.get(unit, {}).get(length)
-def _find_unit_pattern(unit_id: str, locale: Locale | str | None = LC_NUMERIC) -> str | None:
+def _find_unit_pattern(unit_id: str, locale: Locale | str | None = None) -> str | None:
"""
Expand a unit into a qualified form.
:param unit_id: the code of a measurement unit.
:return: A key to the `unit_patterns` mapping, or None.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
unit_patterns = locale._data["unit_patterns"]
if unit_id in unit_patterns:
return unit_id
measurement_unit: str,
length: Literal['short', 'long', 'narrow'] = 'long',
format: str | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str:
https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
:param length: "short", "long" or "narrow"
:param format: An optional format, as accepted by `format_decimal`.
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
q_unit = _find_unit_pattern(measurement_unit, locale=locale)
if not q_unit:
def _find_compound_unit(
numerator_unit: str,
denominator_unit: str,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
) -> str | None:
"""
Find a predefined compound unit pattern.
:param numerator_unit: The numerator unit's identifier
:param denominator_unit: The denominator unit's identifier
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:return: A key to the `unit_patterns` mapping, or None.
:rtype: str|None
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
# Qualify the numerator and denominator units. This will turn possibly partial
# units like "kilometer" or "hour" into actual units like "length-kilometer" and
denominator_unit: str | None = None,
length: Literal["short", "long", "narrow"] = "long",
format: str | None = None,
- locale: Locale | str | None = LC_NUMERIC,
+ locale: Locale | str | None = None,
*,
numbering_system: Literal["default"] | str = "latn",
) -> str | None:
:param denominator_unit: The denominator unit. See `format_unit`.
:param length: The formatting length. "short", "long" or "narrow"
:param format: An optional format, as accepted by `format_decimal`.
- :param locale: the `Locale` object or locale identifier
+ :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
:param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
The special value "default" will use the default numbering system of the locale.
:return: A formatted compound value.
:raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
"""
- locale = Locale.parse(locale)
+ locale = Locale.parse(locale or LC_NUMERIC)
# Look for a specific compound unit first...
== 'US$0,00') # other
+def test_format_currency_with_none_locale_with_default(monkeypatch):
+ """Test that the default locale is used when locale is None."""
+ monkeypatch.setattr(numbers, "LC_NUMERIC", "fi_FI")
+ assert numbers.format_currency(0, "USD", locale=None) == "0,00\xa0$"
+
+
def test_format_currency_format_type():
assert (numbers.format_currency(1099.98, 'USD', locale='en_US',
format_type="standard")
projects / thirdparty / babel.git / commitdiff
