usse/scrape/venv/lib/python3.10/site-packages/babel/plural.py
2023-12-22 15:26:01 +01:00

642 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
babel.numbers
~~~~~~~~~~~~~
CLDR Plural support. See UTS #35.
:copyright: (c) 2013-2023 by the Babel Team.
:license: BSD, see LICENSE for more details.
"""
from __future__ import annotations
import decimal
import re
from collections.abc import Iterable, Mapping
from typing import TYPE_CHECKING, Any, Callable
if TYPE_CHECKING:
from typing_extensions import Literal
_plural_tags = ('zero', 'one', 'two', 'few', 'many', 'other')
_fallback_tag = 'other'
def extract_operands(source: float | decimal.Decimal) -> tuple[decimal.Decimal | int, int, int, int, int, int, Literal[0], Literal[0]]:
"""Extract operands from a decimal, a float or an int, according to `CLDR rules`_.
The result is an 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]
"""
n = abs(source)
i = int(n)
if isinstance(n, float):
if i == n:
n = i
else:
# Cast the `float` to a number via the string representation.
# This is required for Python 2.6 anyway (it will straight out fail to
# do the conversion otherwise), and it's highly unlikely that the user
# actually wants the lossless conversion behavior (quoting the Python
# documentation):
# > If value is a float, the binary floating point value is losslessly
# > converted to its exact decimal equivalent.
# > This conversion can often require 53 or more digits of precision.
# Should the user want that behavior, they can simply pass in a pre-
# converted `Decimal` instance of desired accuracy.
n = decimal.Decimal(str(n))
if isinstance(n, decimal.Decimal):
dec_tuple = n.as_tuple()
exp = dec_tuple.exponent
fraction_digits = dec_tuple.digits[exp:] if exp < 0 else ()
trailing = ''.join(str(d) for d in fraction_digits)
no_trailing = trailing.rstrip('0')
v = len(trailing)
w = len(no_trailing)
f = int(trailing or 0)
t = int(no_trailing or 0)
else:
v = w = f = t = 0
c = e = 0 # TODO: c and e are not supported
return n, i, v, w, f, t, c, e
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:
>>> rule = PluralRule({'one': 'n is 1'})
>>> rule(1)
'one'
>>> rule(2)
'other'
Currently the CLDR defines these tags: zero, one, two, few, many and
other where other is an implicit default. Rules should be mutually
exclusive; for a given numeric value, only one rule should apply (i.e.
the condition should only be true for one of the plural rule elements.
.. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Language_Plural_Rules
"""
__slots__ = ('abstract', '_func')
def __init__(self, rules: Mapping[str, str] | Iterable[tuple[str, str]]) -> None:
"""Initialize the rule instance.
:param rules: a list of ``(tag, expr)``) tuples with the rules
conforming to UTS #35 or a dict with the tags as keys
and expressions as values.
:raise RuleError: if the expression is malformed
"""
if isinstance(rules, Mapping):
rules = rules.items()
found = set()
self.abstract: list[tuple[str, Any]] = []
for key, expr in sorted(rules):
if key not in _plural_tags:
raise ValueError(f"unknown tag {key!r}")
elif key in found:
raise ValueError(f"tag {key!r} defined twice")
found.add(key)
ast = _Parser(expr).ast
if ast:
self.abstract.append((key, ast))
def __repr__(self) -> str:
rules = self.rules
args = ", ".join([f"{tag}: {rules[tag]}" for tag in _plural_tags if tag in rules])
return f"<{type(self).__name__} {args!r}>"
@classmethod
def parse(cls, rules: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> PluralRule:
"""Create a `PluralRule` instance for the given rules. If the rules
are a `PluralRule` object, that object is returned.
:param rules: the rules as list or dict, or a `PluralRule` object
:raise RuleError: if the expression is malformed
"""
if isinstance(rules, PluralRule):
return rules
return cls(rules)
@property
def rules(self) -> Mapping[str, str]:
"""The `PluralRule` as a dict of unicode plural rules.
>>> rule = PluralRule({'one': 'n is 1'})
>>> rule.rules
{'one': 'n is 1'}
"""
_compile = _UnicodeCompiler().compile
return {tag: _compile(ast) for tag, ast in self.abstract}
@property
def tags(self) -> frozenset[str]:
"""A set of explicitly defined tags in this rule. The implicit default
``'other'`` rules is not part of this set unless there is an explicit
rule for it.
"""
return frozenset(i[0] for i in self.abstract)
def __getstate__(self) -> list[tuple[str, Any]]:
return self.abstract
def __setstate__(self, abstract: list[tuple[str, Any]]) -> None:
self.abstract = abstract
def __call__(self, n: float | decimal.Decimal) -> str:
if not hasattr(self, '_func'):
self._func = to_python(self)
return self._func(n)
def to_javascript(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
"""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
"""
to_js = _JavaScriptCompiler().compile
result = ['(function(n) { return ']
for tag, ast in PluralRule.parse(rule).abstract:
result.append(f"{to_js(ast)} ? {tag!r} : ")
result.append('%r; })' % _fallback_tag)
return ''.join(result)
def to_python(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> Callable[[float | decimal.Decimal], str]:
"""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
"""
namespace = {
'IN': in_range_list,
'WITHIN': within_range_list,
'MOD': cldr_modulo,
'extract_operands': extract_operands,
}
to_python_func = _PythonCompiler().compile
result = [
'def evaluate(n):',
' n, i, v, w, f, t, c, e = extract_operands(n)',
]
for tag, ast in PluralRule.parse(rule).abstract:
# the str() call is to coerce the tag to the native string. It's
# a limited ascii restricted set of tags anyways so that is fine.
result.append(f" if ({to_python_func(ast)}): return {str(tag)!r}")
result.append(f" return {_fallback_tag!r}")
code = compile('\n'.join(result), '<rule>', 'exec')
eval(code, namespace)
return namespace['evaluate']
def to_gettext(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
"""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
"""
rule = PluralRule.parse(rule)
used_tags = rule.tags | {_fallback_tag}
_compile = _GettextCompiler().compile
_get_index = [tag for tag in _plural_tags if tag in used_tags].index
result = [f"nplurals={len(used_tags)}; plural=("]
for tag, ast in rule.abstract:
result.append(f"{_compile(ast)} ? {_get_index(tag)} : ")
result.append(f"{_get_index(_fallback_tag)});")
return ''.join(result)
def in_range_list(num: float | decimal.Decimal, range_list: Iterable[Iterable[float | decimal.Decimal]]) -> bool:
"""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
"""
return num == int(num) and within_range_list(num, range_list)
def within_range_list(num: float | decimal.Decimal, range_list: Iterable[Iterable[float | decimal.Decimal]]) -> bool:
"""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
"""
return any(num >= min_ and num <= max_ for min_, max_ in range_list)
def cldr_modulo(a: float, b: float) -> float:
"""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
"""
reverse = 0
if a < 0:
a *= -1
reverse = 1
if b < 0:
b *= -1
rv = a % b
if reverse:
rv *= -1
return rv
class RuleError(Exception):
"""Raised if a rule is malformed."""
_VARS = {
'n', # absolute value of the source number.
'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 fraction digits in n, with trailing zeros.*
't', # visible fraction 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.
}
_RULES: list[tuple[str | None, re.Pattern[str]]] = [
(None, re.compile(r'\s+', re.UNICODE)),
('word', re.compile(fr'\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)) # U+2026: ELLIPSIS
]
def tokenize_rule(s: str) -> list[tuple[str, str]]:
s = s.split('@')[0]
result: list[tuple[str, str]] = []
pos = 0
end = len(s)
while pos < end:
for tok, rule in _RULES:
match = rule.match(s, pos)
if match is not None:
pos = match.end()
if tok:
result.append((tok, match.group()))
break
else:
raise RuleError('malformed CLDR pluralization rule. '
'Got unexpected %r' % s[pos])
return result[::-1]
def test_next_token(
tokens: list[tuple[str, str]],
type_: str,
value: str | None = None,
) -> list[tuple[str, str]] | bool:
return tokens and tokens[-1][0] == type_ and \
(value is None or tokens[-1][1] == value)
def skip_token(tokens: list[tuple[str, str]], type_: str, value: str | None = None):
if test_next_token(tokens, type_, value):
return tokens.pop()
def value_node(value: int) -> tuple[Literal['value'], tuple[int]]:
return 'value', (value, )
def ident_node(name: str) -> tuple[str, tuple[()]]:
return name, ()
def range_list_node(
range_list: Iterable[Iterable[float | decimal.Decimal]],
) -> tuple[Literal['range_list'], Iterable[Iterable[float | decimal.Decimal]]]:
return 'range_list', range_list
def negate(rv: tuple[Any, ...]) -> tuple[Literal['not'], tuple[tuple[Any, ...]]]:
return 'not', (rv,)
class _Parser:
"""Internal parser. This class can translate a single rule into an abstract
tree of tuples. It implements the following grammar::
condition = and_condition ('or' and_condition)*
('@integer' samples)?
('@decimal' samples)?
and_condition = relation ('and' relation)*
relation = is_relation | in_relation | within_relation
is_relation = expr 'is' ('not')? value
in_relation = expr (('not')? 'in' | '=' | '!=') range_list
within_relation = expr ('not')? 'within' range_list
expr = operand (('mod' | '%') value)?
operand = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
range_list = (range | value) (',' range_list)*
value = digit+
digit = 0|1|2|3|4|5|6|7|8|9
range = value'..'value
samples = sampleRange (',' sampleRange)* (',' (''|'...'))?
sampleRange = decimalValue '~' decimalValue
decimalValue = value ('.' value)?
- Whitespace can occur between or around any of the above tokens.
- Rules should be mutually exclusive; for a given numeric value, only one
rule should apply (i.e. the condition should only be true for one of
the plural rule elements).
- The in and within relations can take comma-separated lists, such as:
'n in 3,5,7..15'.
- Samples are ignored.
The translator parses the expression on instantiation into an attribute
called `ast`.
"""
def __init__(self, string):
self.tokens = tokenize_rule(string)
if not self.tokens:
# If the pattern is only samples, it's entirely possible
# no stream of tokens whatsoever is generated.
self.ast = None
return
self.ast = self.condition()
if self.tokens:
raise RuleError(f"Expected end of rule, got {self.tokens[-1][1]!r}")
def expect(self, type_, value=None, term=None):
token = skip_token(self.tokens, type_, value)
if token is not None:
return token
if term is None:
term = repr(value is None and type_ or value)
if not self.tokens:
raise RuleError(f"expected {term} but end of rule reached")
raise RuleError(f"expected {term} but got {self.tokens[-1][1]!r}")
def condition(self):
op = self.and_condition()
while skip_token(self.tokens, 'word', 'or'):
op = 'or', (op, self.and_condition())
return op
def and_condition(self):
op = self.relation()
while skip_token(self.tokens, 'word', 'and'):
op = 'and', (op, self.relation())
return op
def relation(self):
left = self.expr()
if skip_token(self.tokens, 'word', 'is'):
return skip_token(self.tokens, 'word', 'not') and 'isnot' or 'is', \
(left, self.value())
negated = skip_token(self.tokens, 'word', 'not')
method = 'in'
if skip_token(self.tokens, 'word', 'within'):
method = 'within'
else:
if not skip_token(self.tokens, 'word', 'in'):
if negated:
raise RuleError('Cannot negate operator based rules.')
return self.newfangled_relation(left)
rv = 'relation', (method, left, self.range_list())
return negate(rv) if negated else rv
def newfangled_relation(self, left):
if skip_token(self.tokens, 'symbol', '='):
negated = False
elif skip_token(self.tokens, 'symbol', '!='):
negated = True
else:
raise RuleError('Expected "=" or "!=" or legacy relation')
rv = 'relation', ('in', left, self.range_list())
return negate(rv) if negated else rv
def range_or_value(self):
left = self.value()
if skip_token(self.tokens, 'ellipsis'):
return left, self.value()
else:
return left, left
def range_list(self):
range_list = [self.range_or_value()]
while skip_token(self.tokens, 'symbol', ','):
range_list.append(self.range_or_value())
return range_list_node(range_list)
def expr(self):
word = skip_token(self.tokens, 'word')
if word is None or word[1] not in _VARS:
raise RuleError('Expected identifier variable')
name = word[1]
if skip_token(self.tokens, 'word', 'mod'):
return 'mod', ((name, ()), self.value())
elif skip_token(self.tokens, 'symbol', '%'):
return 'mod', ((name, ()), self.value())
return ident_node(name)
def value(self):
return value_node(int(self.expect('value')[1]))
def _binary_compiler(tmpl):
"""Compiler factory for the `_Compiler`."""
return lambda self, left, right: tmpl % (self.compile(left), self.compile(right))
def _unary_compiler(tmpl):
"""Compiler factory for the `_Compiler`."""
return lambda self, x: tmpl % self.compile(x)
compile_zero = lambda x: '0'
class _Compiler:
"""The compilers are able to transform the expressions into multiple
output formats.
"""
def compile(self, arg):
op, args = arg
return getattr(self, f"compile_{op}")(*args)
compile_n = lambda x: 'n'
compile_i = lambda x: 'i'
compile_v = lambda x: 'v'
compile_w = lambda x: 'w'
compile_f = lambda x: 'f'
compile_t = lambda x: 't'
compile_c = lambda x: 'c'
compile_e = lambda x: 'e'
compile_value = lambda x, v: str(v)
compile_and = _binary_compiler('(%s && %s)')
compile_or = _binary_compiler('(%s || %s)')
compile_not = _unary_compiler('(!%s)')
compile_mod = _binary_compiler('(%s %% %s)')
compile_is = _binary_compiler('(%s == %s)')
compile_isnot = _binary_compiler('(%s != %s)')
def compile_relation(self, method, expr, range_list):
raise NotImplementedError()
class _PythonCompiler(_Compiler):
"""Compiles an expression to Python."""
compile_and = _binary_compiler('(%s and %s)')
compile_or = _binary_compiler('(%s or %s)')
compile_not = _unary_compiler('(not %s)')
compile_mod = _binary_compiler('MOD(%s, %s)')
def compile_relation(self, method, expr, range_list):
ranges = ",".join([f"({self.compile(a)}, {self.compile(b)})" for (a, b) in range_list[1]])
return f"{method.upper()}({self.compile(expr)}, [{ranges}])"
class _GettextCompiler(_Compiler):
"""Compile into a gettext plural expression."""
compile_i = _Compiler.compile_n
compile_v = compile_zero
compile_w = compile_zero
compile_f = compile_zero
compile_t = compile_zero
def compile_relation(self, method, expr, range_list):
rv = []
expr = self.compile(expr)
for item in range_list[1]:
if item[0] == item[1]:
rv.append(f"({expr} == {self.compile(item[0])})")
else:
min, max = map(self.compile, item)
rv.append(f"({expr} >= {min} && {expr} <= {max})")
return f"({' || '.join(rv)})"
class _JavaScriptCompiler(_GettextCompiler):
"""Compiles the expression to plain of JavaScript."""
# XXX: presently javascript does not support any of the
# fraction support and basically only deals with integers.
compile_i = lambda x: 'parseInt(n, 10)'
compile_v = compile_zero
compile_w = compile_zero
compile_f = compile_zero
compile_t = compile_zero
def compile_relation(self, method, expr, range_list):
code = _GettextCompiler.compile_relation(
self, method, expr, range_list)
if method == 'in':
expr = self.compile(expr)
code = f"(parseInt({expr}, 10) == {expr} && {code})"
return code
class _UnicodeCompiler(_Compiler):
"""Returns a unicode pluralization rule again."""
# XXX: this currently spits out the old syntax instead of the new
# one. We can change that, but it will break a whole bunch of stuff
# for users I suppose.
compile_is = _binary_compiler('%s is %s')
compile_isnot = _binary_compiler('%s is not %s')
compile_and = _binary_compiler('%s and %s')
compile_or = _binary_compiler('%s or %s')
compile_mod = _binary_compiler('%s mod %s')
def compile_not(self, relation):
return self.compile_relation(*relation[1], negated=True)
def compile_relation(self, method, expr, range_list, negated=False):
ranges = []
for item in range_list[1]:
if item[0] == item[1]:
ranges.append(self.compile(item[0]))
else:
ranges.append(f"{self.compile(item[0])}..{self.compile(item[1])}")
return f"{self.compile(expr)}{' not' if negated else ''} {method} {','.join(ranges)}"