]jZ U d Z ddlmZ ddlZddlZddlmZmZ ddlm Z m
Z
m Z e rddl m
Z
dZdZdUd
Z G d d ZdVdZdWdZdVdZdXdZdXd ZdYd Z G d! d"e Zh d#Zd ej d$ej fd% ej d&d' e d( fd) ej d* fd+ ej d, fd- ej d.ej fgZ d/e d0< dZd3Z d[d\d8Z!d[d]d9Z"d^d<Z#d_d?Z$d`dAZ%dadEZ& G dF dG Z'dH Z(dI Z)dJ Z* G dK dL Z+ G dM dNe+ Z, G dO dPe+ Z- G dQ dRe- Z. G dS dTe+ Z/dS )bz
babel.numbers
~~~~~~~~~~~~~
CLDR Plural support. See UTS #35.
:copyright: (c) 2013-2023 by the Babel Team.
:license: BSD, see LICENSE for more details.
) annotationsN)IterableMapping)
TYPE_CHECKINGAnyCallable)Literal)zeroonetwofewmanyotherr sourcefloat | decimal.DecimalreturnMtuple[decimal.Decimal | int, int, int, int, int, int, Literal[0], Literal[0]]c j t | }t | }t |t r*||k r|}n!t j t
| }t |t j r| }|j }|dk r|j |d nd}d
d |D }| d }t | }t | } t |pd }
t |pd } ndx}x} x}
} dx} }
|||| |
| | |
fS )u 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]
r N c 3 4 K | ]}t | V d S Nstr).0ds l/builddir/build/BUILD/imunify360-venv-2.6.3/opt/imunify360/venv/lib/python3.11/site-packages/babel/plural.py <genexpr>z#extract_operands.<locals>.<genexpr>G s( ;;a3q66;;;;;; 0)
absint
isinstancefloatdecimalDecimalr as_tupleexponentdigitsjoinrstriplen)r ni dec_tupleexpfraction_digitstrailing no_trailingvwftces r extract_operandsr: s< 2 F A AA!U ( 66AA A''A!W_%% JJLL 47!GG)*3440077;;?;;;;; ooc** MM
A q ! !AA
IA aAq!Q !!r c e Zd ZdZdZddZdd Zedd Ze dd
Z
e d d Z d dZ d dZ
d dZdS )
PluralRuleaf 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
)abstract_funcrules-Mapping[str, str] | Iterable[tuple[str, str]]r Nonec t |t r| }t }g | _ t | D ]~\ }}|t vrt d| ||v rt d|d | | t | j
}|r | j ||f dS )a$ 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
z unknown tag ztag z defined twiceN) r# r itemssetr= sorted _plural_tags
ValueErroradd_Parserastappend)selfr? foundkeyexprrJ s r __init__zPluralRule.__init__j s eW % % "KKMME/1
1 1IC,&& !7!7!7888 !=!=!=!=>>> IIcNNN$--#C
1
$$c3Z000 1 1r r c | j d fdt D }dt | j d|dS )N, c 2 g | ]}|v | d | S )z: r )r tagr? s r
<listcomp>z'PluralRule.__repr__.<locals>.<listcomp> s1 YYYSCSXLLS00E#J00LLLr < >)r? r* rF type__name__)rL argsr? s @r __repr__zPluralRule.__repr__ sR
yyYYYYLYYYZZ24::&222222r :Mapping[str, str] | Iterable[tuple[str, str]] | PluralRulec F t |t r|S | | S )a
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
)r# r< )clsr? s r parsezPluralRule.parse s) eZ ( ( Ls5zzr Mapping[str, str]c P t j fd| j D S )zThe `PluralRule` as a dict of unicode plural rules.
>>> rule = PluralRule({'one': 'n is 1'})
>>> rule.rules
{'one': 'n is 1'}
c . i | ]\ }}| | S r r )r rT rJ _compiles r
<dictcomp>z$PluralRule.rules.<locals>.<dictcomp> s' AAAxsCXXc]]AAAr )_UnicodeCompilercompiler= )rL rd s @r r? zPluralRule.rules s/ $%%-AAAA4=AAAAr frozenset[str]c > t d | j D S )zA 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.
c 3 & K | ] }|d V
dS )r Nr )r r. s r r z"PluralRule.tags.<locals>.<genexpr> s& 55!1555555r ) frozensetr= rL s r tagszPluralRule.tags s# 55t}555555r list[tuple[str, Any]]c | j S r r= rl s r __getstate__zPluralRule.__getstate__ s
} r r= c || _ d S r rp )rL r= s r __setstate__zPluralRule.__setstate__ s
r r- r c t t | d st | | _ | | S )Nr> )hasattr to_pythonr> )rL r- s r __call__zPluralRule.__call__ s1 tW%% )"4 DJzz!}} r N)r? r@ r rA )r r )r? r] r r< )r ra )r rh )r rn )r= rn r rA )r- r r r )rZ
__module__ __qualname____doc__ __slots__rP r\ classmethodr` propertyr? rm rq rs rw r r r r< r< S s ( &I1 1 1 1,3 3 3 3
[ B B B XB 6 6 6 X6 ! ! ! ! r r< ruler] r c $ t j }dg}t | j D ])\ }}| || d|d *| dt z d | S )a 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
z(function(n) { return ? : z%r; })r )_JavaScriptCompilerrg r< r` r= rK
_fallback_tagr* )r~ to_jsresultrT rJ s r
to_javascriptr s
! ! )E&
'F $$T**3 4 4S
s222223333
MM(]*+++
776??r (Callable[[float | decimal.Decimal], str]c t t t t d}t j }ddg}t | j D ]6\ }}| d || dt | 7| dt t d | dd }t || |d
S ) a< 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
)INWITHINMODr: zdef evaluate(n):z- n, i, v, w, f, t, c, e = extract_operands(n)z if (z
): return z return
z<rule>execevaluate)
in_range_listwithin_range_list cldr_modulor: _PythonCompilerrg r< r` r= rK r r r* eval)r~ namespaceto_python_funcr rT rJ codes r rv rv s ( # , I %&&.N7F $$T**3 K KS
InnS 1 1IISXXIIJJJJ
MM.]../// 499V$$h 7 7Dy Z r c t | } | j t hz t j }fdt D j }dt dg}| j D ]2\ }}|
|| d || d 3|
|t d d | S )a 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
c g | ]}|v | S r r )r rT used_tagss r rU z to_gettext.<locals>.<listcomp> s# BBB# 1A1A#1A1A1Ar z nplurals=z
; plural=(r r z);r ) r< r` rm r _GettextCompilerrg rF indexr, r= rK r* )r~ rd
_get_indexr rT rJ r s @r
to_gettextr s D ! !D ]O+I !!)HBBBB BBBHJ4#i..444
5FM A AS
# ??::c?????@@@@
MMZZ
..222333
776??r num
range_list+Iterable[Iterable[float | decimal.Decimal]]boolc H | t | k ot | | S )a 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
)r" r r r s r r r s$ " #c((? A 0j A AAr c : t fd|D S )a 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
c 3 6 K | ]\ }}|k o|k V d S r r )r min_max_r s r r z$within_range_list.<locals>.<genexpr>+ s4 HHztTsd{*sd{HHHHHHr )anyr s ` r r r s( " HHHHZHHH H HHr ar$ bc R d}| dk r| dz } d}|dk r|dz }| |z }|r|dz }|S )zJavaish 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
r r )r r reverservs r r r . sQ G1uu R1uu R
QB
b
Ir c e Zd ZdZdS ) RuleErrorz Raised if a rule is malformed.N)rZ rx ry rz r r r r r E s ((((r r > r8 r9 r6 r. r- r7 r4 r5 z\s+wordz"\b(and|or|is|(?:with)?in|not|mod|[r z])\bvaluez\d+symbolz%|,|!=|=ellipsisz\.{2,3}|\u2026z(list[tuple[str | None, re.Pattern[str]]]_RULESslist[tuple[str, str]]c | d d } g }d}t | }||k rt D ]^\ }}| | | }|A| }|r)| || f n_t d| | z ||k |d d d S )N@r z5malformed CLDR pluralization rule. Got unexpected %rr )splitr, r matchendrK groupr )r r posr tokr~ r s r
tokenize_ruler ] s QA$&F
C
a&&C
)) : :ICJJq#&&E iikk 8MM3
"6777 ! 023C& 9 : :
: )) $$B$<r tokenstype_
str | None list[tuple[str, str]] | boolc V | o'| d d |k o|d u p| d d |k S )Nr r r r r r r s r test_next_tokenr p s>
2fRjmu, 2 $ 0&*Q-502r c P t | || r| S d S r )r popr s r
skip_tokenr y s. vue,, zz|| r r" #tuple[Literal['value'], tuple[int]]c d| ffS )Nr r )r s r
value_noder ~ s UI r nametuple[str, tuple[()]]c
| dfS )Nr r )r s r
ident_noder s 8Or Ituple[Literal['range_list'], Iterable[Iterable[float | decimal.Decimal]]]c
d| fS )Nr r )r s r range_list_noder s ##r r tuple[Any, ...]-tuple[Literal['not'], tuple[tuple[Any, ...]]]c d| ffS )Nnotr )r s r negater s 2%<r c P e Zd ZdZd Zd
dZd Zd Zd Zd Z d Z
d
Z d Z d Z
dS )rI u 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`.
c t | | _ | j s d | _ d S | | _ | j r#t d| j d d d S )NzExpected end of rule, got r r )r r rJ conditionr )rL strings r rP z_Parser.__init__ ss #F++ { DH F>>## ; Q OR 9K O OPP P Q Qr Nc t | j || }||S |t |d u r|p| }| j st d| d t d| d| j d d )Nz expected z but end of rule reachedz but got r r )r r reprr )rL r r termtokens r expectz_Parser.expect s 4;u55 L <
/%8599D{ H F F F FGG GIDII4;r?13EIIJJJr c | }t | j dd r.d|| ff}t | j dd .|S )Nr or)
and_conditionr r rL ops r r z_Parser.condition sa
!
!fd33 2D . . 0 011B fd33 2 r c | }t | j dd r.d|| ff}t | j dd .|S )Nr and)relationr r r s r r z_Parser.and_condition sY
]]__fe44 .T]]__--B fe44 . r c | }t | j dd r0t | j dd rdpd|| ffS t | j dd }d}t | j dd rd}n<t | j dd s&|rt d | | S d||| ff}|rt | n|S ) Nr isr isnotinwithinz#Cannot negate operator based rules.r )rO r r r r newfangled_relationr r )rL leftnegatedmethodr s r r z_Parser.relation s yy{{ dk64 0 0 % dk6599EgMtzz||$%
% T[&%88 dk68 4 4 6 FF dk6488
6 K#$IJJJ//555
&$(9(9:
: $,vbzzz",r c t | j dd rd}n(t | j dd rd}nt d dd|| ff}|rt | n|S ) Nr =Fz!=Tz'Expected "=" or "!=" or legacy relationr r )r r r r r )rL r r r s r r z_Parser.newfangled_relation s} dk8S 1 1 GGG
Xt
4
4 GGG EFF F
$doo&7&78
8 $,vbzzz",r c | }t | j d r|| fS ||fS )Nr )r r r )rL r s r range_or_valuez_Parser.range_or_value s@ zz|| dk: . . % %: r c | g}t | j dd r=| | t | j dd =t | S )Nr ,)r r r rK r )rL r s r r z_Parser.range_list sr ))++,
h44 5 d 1 1 3 3 4 4 4 h44 5 z***r c Z t | j d }||d t vrt d |d }t | j dd rd|df| ffS t | j dd rd|df| ffS t | S )Nr r z Expected identifier variablemodr r %)r r _VARSr r r )rL r r s r rO z _Parser.expr s $+v.. <47%// :;; ;Aw dk65 1 1 5D":tzz||44 4
Xs
3
3 5D":tzz||44 4$ r c l t t | d d S )Nr r )r r" r rl s r r z
_Parser.value s) #dkk' 2 21 566777r )NN)rZ rx ry rz rP r r r r r r r rO r r r r rI rI s B Q Q QK K K K - - -"- - - + + + 8 8 8 8 8r rI c fdS )%Compiler factory for the `_Compiler`.c ^ | | | | fz S r rg )rL r righttmpls r <lambda>z"_binary_compiler.<locals>.<lambda> s) TT\\$-?-? eATAT,U%U r r r s `r _binary_compilerr
s U U U UUr c fdS )r c 4 | | z S r r )rL xr s r r z!_unary_compiler.<locals>.<lambda> s 4$,,q//1 r r r s `r _unary_compilerr s 1 1 1 11r c dS )Nr r r s r r r s r c e Zd ZdZd Zd Zd Zd Zd Zd Z d Z
d Z d
Z d Z
ed Z ed
Z ed Z ed Z ed Z ed Zd ZdS ) _CompilerzZThe compilers are able to transform the expressions into multiple
output formats.
c 8 |\ }} t | d| | S )Ncompile_)getattr)rL argr r[ s r rg z_Compiler.compile s( D-wt___--t44r c dS )Nr- r r s r r z_Compiler.<lambda> # r c dS )Nr. r r s r r z_Compiler.<lambda>! r r c dS )Nr4 r r s r r z_Compiler.<lambda>" r r c dS )Nr5 r r s r r z_Compiler.<lambda># r r c dS )Nr6 r r s r r z_Compiler.<lambda>$ r r c dS )Nr7 r r s r r z_Compiler.<lambda>% r r c dS )Nr8 r r s r r z_Compiler.<lambda>& r r c dS )Nr9 r r s r r z_Compiler.<lambda>' r r c t | S r r )r r4 s r r z_Compiler.<lambda>( s Q r z
(%s && %s)z
(%s || %s)z(!%s)z
(%s %% %s)z
(%s == %s)z
(%s != %s)c t r )NotImplementedError)rL r rO r s r compile_relationz_Compiler.compile_relation0 s !###r N)rZ rx ry rz rg compile_n compile_i compile_v compile_w compile_f compile_t compile_c compile_e
compile_valuer compile_and
compile_orr compile_not compile_mod
compile_is
compile_isnotr! r r r r r s 5 5 5
I
I
I
I
I
I
I
I''M""<00K!!,//J!/'**K""<00K!!,//J$$\22M$ $ $ $ $r r c p e Zd ZdZ ed Z ed Z ed Z ed Z d Z
dS )r z!Compiles an expression to Python.z (%s and %s)z
(%s or %s)z(not %s)z MOD(%s, %s)c d fd|d D }| d | d| dS )Nr c t g | ]4\ }}d | d | d5S )(rR )r )r r r rL s r rU z4_PythonCompiler.compile_relation.<locals>.<listcomp>= sE aaa!QDt||ADD$,,q//DDDaaar r r4 z, [z]))r* upperrg )rL r rO r rangess ` r r! z _PythonCompiler.compile_relation< sc aaaaS]^_S`aaabb,,..DD4<<#5#5DD&DDDDr N) rZ rx ry rz r r+ r, r r- r. r! r r r r r 4 sm ++""=11K!!,//J!/*--K""=11KE E E E Er r c 6 e Zd ZdZej ZeZeZ eZ
eZ d Z dS )r z)Compile into a gettext plural expression.c | g }| | }|d D ]}|d |d k r6| d| d| |d d Jt | j | \ }}| d| d| d| d| d dd | dS )
Nr r r4 z == r5 z >= && z <= z || )rg rK mapr* )rL r rO r r itemminmaxs r r! z!_GettextCompiler.compile_relationJ s
||D!! qM C CDAw$q'!! @d@@ T!W(=(=@@@AAAA t|T22S AdAAAAAA3AAABBBB%6;;r??%%%%r N)
rZ rx ry rz r r" r# compile_zeror$ r% r& r' r! r r r r r A sE 33#I I I I I & & & & &r r c . e Zd ZdZd ZeZeZeZeZ d Z
dS )r z/Compiles the expression to plain of JavaScript.c dS )NzparseInt(n, 10)r r s r r z _JavaScriptCompiler.<lambda>[ s + r c t | ||| }|dk r!| | }d| d| d| d}|S )Nr z
(parseInt(z , 10) == r: r5 )r r! rg )rL r rO r r s r r! z$_JavaScriptCompiler.compile_relationa s_ 00 &$
, , T>><<%%D@@@t@@@@@D r N) rZ rx ry rz r# r? r$ r% r& r' r! r r r r r V sG 99 ,+I I I I I r r c e Zd ZdZ ed Z ed Z ed Z ed Z ed Z d Z
d d Z d
S ) rf z+Returns a unicode pluralization rule again.z%s is %sz %s is not %sz %s and %sz%s or %sz %s mod %sc ( | j |d ddiS )Nr r T)r! )rL r s r r- z _UnicodeCompiler.compile_notw s $t$hqk@4@@@r Fc g }|d D ]}|d |d k r/| | |d C| | |d d| |d | | |rdnd d| dd | S )Nr r z..z notr rW r )rK rg r* )rL r rO r r r7 r< s r r! z!_UnicodeCompiler.compile_relationz s qM S SDAw$q'!!
dll47 3 34444
d1g!6!6 Q Q$,,tAw:O:O Q QRRRR,,t$$]&?ffR]]&]]388TZK[K[]]]r N)F) rZ rx ry rz r r/ r0 r+ r, r. r- r! r r r rf rf j s 55 "!*--J$$^44M"";//K!!*--J"";//KA A A^ ^ ^ ^ ^ ^r rf )r r r r )r~ r] r r )r~ r] r r )r r r r r r )r r$ r r$ r r$ )r r r r r )r r r r r r r r )r r r r r r )r r" r r )r r r r )r r r r )r r r r )0rz
__future__r r% recollections.abcr r typingr r r typing_extensionsr rF r r: r< r rv r r r r Exceptionr r rg UNICODEr* r __annotations__r r r r r r r rI r r r? r r r r rf r r r <module>rN s # " " " " " - - - - - - - - / / / / / / / / / / *))))))=
8" 8" 8" 8"vZ Z Z Z Z Z Z Z z .%! %! %! %!P .B B B B(I I I I( .) ) ) ) ) ) ) )
:2:fbj ) )* ZRZRbggennRRR
S
ST jbj !
zrz+&&' -rz::; 4 , 2 2 2 2 2
$ $ $ $ w8 w8 w8 w8 w8 w8 w8 w8tV V V
2 2 2
} $ $ $ $ $ $ $ $:
E
E
E
E
Ei
E
E
E& & & & &y & & &* * (^ ^ ^ ^ ^y ^ ^ ^ ^ ^r