babel.plural

module documentation

(source)

Class	`PluralRule`	Represents a set of language pluralization rules. The constructor accepts a list of (tag, expr) tuples or a dict of `CLDR rules`_. The resulting object is callable and accepts one parameter with a positive or negative number (both integer and float) for the number that indicates the plural form for a string and returns the tag for the format:...
Exception	`RuleError`	Raised if a rule is malformed.
Function	`cldr_modulo`	Javaish modulo. This modulo operator returns the value with the sign of the dividend rather than the divisor like Python does:
Function	`extract_operands`	Extract operands from a decimal, a float or an int, according to `CLDR rules`_.
Function	`ident_node`	Undocumented
Function	`in_range_list`	Integer range list test. This is the callback for the "in" operator of the UTS #35 pluralization rule language:
Function	`negate`	Undocumented
Function	`range_list_node`	Undocumented
Function	`skip_token`	Undocumented
Function	`test_next_token`	Undocumented
Function	`to_gettext`	The plural rule as gettext expression. The gettext expression is technically limited to integers and returns indices rather than tags.
Function	`to_javascript`	Convert a list/dict of rules or a `PluralRule` object into a JavaScript function. This function depends on no external library:
Function	`to_python`	Convert a list/dict of rules or a `PluralRule` object into a regular Python function. This is useful in situations where you need a real function and don't are about the actual rule object:
Function	`tokenize_rule`	Undocumented
Function	`value_node`	Undocumented
Function	`within_range_list`	Float range test. This is the callback for the "within" operator of the UTS #35 pluralization rule language:
Variable	`compile_zero`	Undocumented
Class	`_Compiler`	The compilers are able to transform the expressions into multiple output formats.
Class	`_GettextCompiler`	Compile into a gettext plural expression.
Class	`_JavaScriptCompiler`	Compiles the expression to plain of JavaScript.
Class	`_Parser`	Internal parser. This class can translate a single rule into an abstract tree of tuples. It implements the following grammar::
Class	`_PythonCompiler`	Compiles an expression to Python.
Class	`_UnicodeCompiler`	Returns a unicode pluralization rule again.
Function	`_binary_compiler`	Compiler factory for the `_Compiler`.
Function	`_unary_compiler`	Compiler factory for the `_Compiler`.
Constant	`_RULES`	Undocumented
Constant	`_VARS`	Undocumented
Variable	`_fallback_tag`	Undocumented
Variable	`_plural_tags`	Undocumented

def cldr_modulo(a: float, b: float) -> float: (source) ¶

Javaish modulo. This modulo operator returns the value with the sign of the dividend rather than the divisor like Python does: >>> cldr_modulo(-3, 5) -3 >>> cldr_modulo(-3, -5) -3 >>> cldr_modulo(3, 5) 3

def extract_operands(source: float|decimal.Decimal) -> tuple[decimal.Decimal|int, int, int, int, int, int, Literal[0], Literal[0]]: (source) ¶

Extract operands from a decimal, a float or an int, according to `CLDR rules`_. The result is a 8-tuple (n, i, v, w, f, t, c, e), where those symbols are as follows: ====== =============================================================== Symbol Value ------ --------------------------------------------------------------- n absolute value of the source number (integer and decimals). i integer digits of n. v number of visible fraction digits in n, with trailing zeros. w number of visible fraction digits in n, without trailing zeros. f visible fractional digits in n, with trailing zeros. t visible fractional digits in n, without trailing zeros. c compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting. e currently, synonym for ‘c’. however, may be redefined in the future. ====== =============================================================== .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-61/tr35-numbers.html#Operands :param source: A real number :type source: int|float|decimal.Decimal :return: A n-i-v-w-f-t-c-e tuple :rtype: tuple[decimal.Decimal, int, int, int, int, int, int, int]

def ident_node(name: str) -> tuple[str, tuple[]]: (source) ¶

Undocumented

def in_range_list(num: float|decimal.Decimal, range_list: Iterable[Iterable[float|decimal.Decimal]]) -> bool: (source) ¶

Integer range list test. This is the callback for the "in" operator of the UTS #35 pluralization rule language: >>> in_range_list(1, [(1, 3)]) True >>> in_range_list(3, [(1, 3)]) True >>> in_range_list(3, [(1, 3), (5, 8)]) True >>> in_range_list(1.2, [(1, 4)]) False >>> in_range_list(10, [(1, 4)]) False >>> in_range_list(10, [(1, 4), (6, 8)]) False

def negate(rv: tuple[Any, ...]) -> tuple[Literal['not'], tuple[tuple[Any, ...]]]: (source) ¶

Undocumented

def range_list_node(range_list: Iterable[Iterable[float|decimal.Decimal]]) -> tuple[Literal['range_list'], Iterable[Iterable[float|decimal.Decimal]]]: (source) ¶

Undocumented

def skip_token(tokens: list[tuple[str, str]], type_: str, value: str|None = None): (source) ¶

Undocumented

def test_next_token(tokens: list[tuple[str, str]], type_: str, value: str|None = None) -> list[tuple[str, str]]|bool: (source) ¶

Undocumented

def to_gettext(rule: (Mapping[str, str]|Iterable[tuple[str, str]])|PluralRule) -> str: (source) ¶

The plural rule as gettext expression. The gettext expression is technically limited to integers and returns indices rather than tags. >>> to_gettext({'one': 'n is 1', 'two': 'n is 2'}) 'nplurals=3; plural=((n == 1) ? 0 : (n == 2) ? 1 : 2);' :param rule: the rules as list or dict, or a `PluralRule` object :raise RuleError: if the expression is malformed

def to_javascript(rule: (Mapping[str, str]|Iterable[tuple[str, str]])|PluralRule) -> str: (source) ¶

Convert a list/dict of rules or a `PluralRule` object into a JavaScript function. This function depends on no external library: >>> to_javascript({'one': 'n is 1'}) "(function(n) { return (n == 1) ? 'one' : 'other'; })" Implementation detail: The function generated will probably evaluate expressions involved into range operations multiple times. This has the advantage that external helper functions are not required and is not a big performance hit for these simple calculations. :param rule: the rules as list or dict, or a `PluralRule` object :raise RuleError: if the expression is malformed

def to_python(rule: (Mapping[str, str]|Iterable[tuple[str, str]])|PluralRule) -> Callable[[float|decimal.Decimal], str]: (source) ¶

Convert a list/dict of rules or a `PluralRule` object into a regular Python function. This is useful in situations where you need a real function and don't are about the actual rule object: >>> func = to_python({'one': 'n is 1', 'few': 'n in 2..4'}) >>> func(1) 'one' >>> func(3) 'few' >>> func = to_python({'one': 'n in 1,11', 'few': 'n in 3..10,13..19'}) >>> func(11) 'one' >>> func(15) 'few' :param rule: the rules as list or dict, or a `PluralRule` object :raise RuleError: if the expression is malformed

def tokenize_rule(s: str) -> list[tuple[str, str]]: (source) ¶

Undocumented

def value_node(value: int) -> tuple[Literal['value'], tuple[int]]: (source) ¶

Undocumented

def within_range_list(num: float|decimal.Decimal, range_list: Iterable[Iterable[float|decimal.Decimal]]) -> bool: (source) ¶

Float range test. This is the callback for the "within" operator of the UTS #35 pluralization rule language: >>> within_range_list(1, [(1, 3)]) True >>> within_range_list(1.0, [(1, 3)]) True >>> within_range_list(1.2, [(1, 4)]) True >>> within_range_list(8.8, [(1, 4), (7, 15)]) True >>> within_range_list(10, [(1, 4)]) False >>> within_range_list(10.5, [(1, 4), (20, 30)]) False

compile_zero = (source) ¶

Undocumented

def _binary_compiler(tmpl): (source) ¶

Compiler factory for the `_Compiler`.

def _unary_compiler(tmpl): (source) ¶

Compiler factory for the `_Compiler`.

_RULES: list[tuple[str|None, re.Pattern[str]]] = (source) ¶

Undocumented

Value

[(None, re.compile(r'\s+', re.UNICODE)),
 ('word',
  re.compile(f"""\\b(and|or|is|(?:with)?in|not|mod|[{''.join(_VARS)}])\\b""")),
 ('value', re.compile(r'\d+')),
 ('symbol', re.compile(r'%|,|!=|=')),
 ('ellipsis', re.compile(r'\.{2,3}|\u2026', re.UNICODE))]

_VARS: set[str] = (source) ¶

Undocumented

Value

set(['n', 'i', 'v', 'w', 'f', 't', 'c', 'e'])

_fallback_tag: str = (source) ¶

Undocumented

_plural_tags: tuple[str, ...] = (source) ¶

Undocumented