Name	Size	Mode	Actions
core.cpython-310.pyc	35218	0644	editdlrm
dates.cpython-310.pyc	55267	0644	editdlrm
languages.cpython-310.pyc	3125	0644	editdlrm
lists.cpython-310.pyc	2671	0644	editdlrm
localedata.cpython-310.pyc	7550	0644	editdlrm
numbers.cpython-310.pyc	30964	0644	editdlrm
plural.cpython-310.pyc	22088	0644	editdlrm
support.cpython-310.pyc	22318	0644	editdlrm
units.cpython-310.pyc	8441	0644	editdlrm
util.cpython-310.pyc	7084	0644	editdlrm
_compat.cpython-310.pyc	2143	0644	editdlrm
__init__.cpython-310.pyc	895	0644	editdlrm

o V��\BS� @s�
dZd
dl
Z
d
dlmZ
dZdZdd�ZGdd �d e�Zd d�Z dd �Z dd�Zdd�Zdd�Z dd�ZGdd�de�ZdZde
�de
j�fde
�d�e�
�
fde
�d�
fde
�d�
fd e
�d!e
j�fgZd"d#�ZdBd$d%�
ZdBd&d'�
Zd(d)�Zd*d+�Zd,d-�Zd.d/�ZGd0d1�d1e�Zd2d3�Zd4d5�Zd6d7�Z Gd8d9�d9e�Z!Gd:d;�d;e!�Z"Gdd?�d?e#�Z$Gd@dA�dAe!�Z%dS)Cz� babel.numbers ~~~~~~~~~~~~~ CLDR Plural support. See UTS #35. :copyright: (c) 2013-2019 by the Babel Team. :license: BSD, see LICENSE for more details. �N)
�decimal)�zero�one�two�few�many�otherrc
Cs�t|�
}
t
|
�
}t|
t�r||
kr|}
nt�t|
�
�
}
t|
tj�rY|
��}|j}|d
kr3|j |d�n
d}d� dd�|D�
�
}|�d�
}t|�
}t|�
} t
|pPd
�
} t
|pVd
�
}nd
}} } }|
||| | |fS)a#Extract operands from a decimal, a float or an int, according to `CLDR rules`_. The result is a 6-tuple (n, i, v, w, f, t), 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. ====== =============================================================== .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Operands :param source: A real number :type source: int|float|decimal.Decimal :return: A n-i-v-w-f-t tuple :rtype: tuple[decimal.Decimal, int, int, int, int, int] r
N��c
ss�|]}
t|
�
V
qdS�
N�
�str)�.0�
dr r �./usr/lib/python3/dist-packages/babel/plural.py� As�z#extract_operands..�
0) �abs�int� isinstance�floatr�Decimalr �as_tuple�exponent�digits�join�rstrip�len)�source�
n�
i� dec_tuple�exp�fraction_digits�trailing�no_trailing�
v�
w�
f�
tr r r�extract_operandss$













r*c@sdeZ
dZd
ZdZdd�Zdd�Zedd��
Ze d d ��
Z e dd�d d�Zdd�Zdd�Z dd�ZdS)� PluralRuleafRepresents 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�_funccCs�t|
t
�r |
��}
t�}g|_tt|
�
�
D],\}}|tv
r#td
|�
�
||vr-td|�
�
|� |�

t |�
j}|rA|j�||f�

qdS)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 zunknown tag %rztag %r defined twiceN) r�dict�items�setr,�sorted�list�_plural_tags� ValueError�add�_Parser�ast�append)�self�rules�found�key�exprr7r r r�__init__cs 











��zPluralRule.__init__c

s,|j�d
t
|�
jd��f
dd�tD�
�
fS)Nz<%s %r>z, c
s$g|]}
|
�vrd|
�|
f�qS)
z%s: %sr �r�tag�
r:r r� }s
�
z'PluralRule.__repr__..)r:�type�__name__rr3�
r9r rAr�__repr__ys 



�zPluralRule.__repr__cCst|
|�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)�clsr:r r r�parse�s 

zPluralRule.parsec

s t�j
�t�f
d
d�|jD�
�
S)z�The `PluralRule` as a dict of unicode plural rules. >>> rule = PluralRule({'one': 'n is 1'}) >>> rule.rules {'one': 'n is 1'} c
sg|] \}
}|
�|�
f�qSr r )rr@r7�
�_compiler rrB�sz$PluralRule.rules..)�_UnicodeCompiler�compiler.r,rEr rIrr:�s
zPluralRule.rulesc

Cstd
d�|j
D�
�
S)Nc
Ssg|]}
|
d�qS)
r
r )rr r r rrB��z'PluralRule...)� frozensetr,�
�
xr r r��rMzPluralRule.z� 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.)
�docc


Cs|jSr�
r,rEr r r�__getstate__��
zPluralRule.__getstate__cCs |
|_dSrrS)r9r,r r r�__setstate__��
zPluralRule.__setstate__cCst|d
�s t
|�
|_|�|
�
S)Nr-)�hasattr� to_pythonr-)r9rr r r�__call__�s


zPluralRule.__call__N)rD� __module__�__qualname__�__doc__� __slots__r>rF�classmethodrH�propertyr:�tagsrTrVrZr r r rr+Ls


 r+c
CsRt�j
}
d
g
}t�|�
jD]\}}|�d|
|�
|f�

q |�dt�

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 %s ? %r : z%r; })r )�_JavaScriptCompilerrLr+rHr,r8� _fallback_tagr)�rule�to_js�resultr@r7r r r� to_javascript�s




rgc
Cs�tt
ttd
�}
t�j}ddg}t�|�
jD]\}}|� d||�
t |�
f�

q|� dt�

td�|�
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 )�IN�WITHIN�MODr*zdef evaluate(n):z' n, i, v, w, f, t = extract_operands(n)z if (%s): return %rz return %r�
z�exec�evaluate)� in_range_list�within_range_list�cldr_modulor*�_PythonCompilerrLr+rHr,r8r rcr�eval)rd� namespace�to_python_funcrfr@r7�coder r rrY�s


�
�



rYc
s�t�
|�
}|jth
B�t�j}
�f
d
d�tD�
j}dt��
g
}|j D]\}}|� d|
|�
||�
f�

q#|� d|t�
�

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
sg|]}
|
�vr|
�qSr r r?�
� used_tagsr rrB��zto_gettext..znplurals=%d; plural=(z %s ? %d : z%d)r )r+rHrarc�_GettextCompilerrLr3�indexrr,r8r)rdrJ� _get_indexrfr@r7r rvr� to_gettext�s 





r|cCs|t|�
ko t
||
�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 )rro��num� range_listr r rrn��rncst�f
d
d�|
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
3s$�|] \}
}�|
ko �|k
V
qdSrr )r�min_�max_�
r~r rr$
s�"z$within_range_list..)
�anyr}r r�rro
r�rocCs@d
}|d
kr|d9}d}|
d
kr|
d9}
||
}|r|d9}|S)z�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 r
������
r )�
a�
b�reverse�rvr r rrp'
s








rpc
@seZ
dZd
ZdS)� RuleErrorzRaised if a rule is malformed.N)rDr[r\r]r r r rr�>
s
r��nivwftz\s+�wordz)\b(and|or|is|(?:with)?in|not|mod|[{0}])\b�valuez\d+�symbolz%|,|!=|=�ellipsisz\.{2,3}|\u2026c
Cs�|�d
�
d}g}
d}t
|�
}||krAtD]\}}|�||�}|du
r4|��}|r2|
�||��f�


n qtd||�
�
||ks|
ddd�S)N�
@r
z5malformed CLDR pluralization rule. Got unexpected %rr�)�splitr�_RULES�match�endr8�groupr�)�
srf�posr��tokrdr�r r r� tokenize_ruleM
s$











�
��r�cCs,|o|d
d|
ko|dup|d
d|kS)Nr�r
r�r ��tokens�type_r�r r r�test_next_token`
s

�r�cCst||
|�r |�
�SdSr)r��popr�r r r� skip_tokene
s

�r�c

C� d
|f
fS)Nr�r )
r�r r r� value_nodej
rWr�c

Cs|d
fS)Nr r )
�namer r r� ident_noden
�
r�c

Csd
|fS)Nrr )
rr r r�range_list_noder
r�r�c

Cr�)N�notr )
r�r r r�negatev
rWr�c@sbeZ
dZd
Zdd�Zddd�
Zdd�Zd d �Zdd�Zd d�Z dd�Z dd�Zdd�Zdd�Z dS)r6u�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 instanciation into an attribute called `ast`. cCsDt|
�
|_
|j
s d|_dS|��|_|j
r td
|j
dd�
�
dS)NzExpected end of rule, got %rr�r�)r�r�r7� conditionr�)r9�stringr r rr>�
s






��z_Parser.__init__NcCsbt|j
|
|�}|du
r |S|durt|dur|
p|�
}|j
s$td
|�
�
td||j
ddf�
�
)Nz#expected %s but end of rule reachedzexpected %s but got %rr�r�)r�r��reprr�)r9r�r��term�tokenr r r�expect�
s







z_Parser.expectc
C�8|��}
t
|jd
d�rd|
|��ff}
t
|jd
d�s|
S)Nr��or)� and_conditionr�r��r9�opr r rr��
� 


�z_Parser.conditionc
Cr�)Nr��and)�relationr�r�r�r r rr��
r�z_Parser.and_conditionc
Cs�|��}
t
|jd
d�rt
|jd
d�rdpd|
|��ffSt
|jd
d�}d}t
|jd
d�r/d}nt
|jd
d�sA|r.r r�r r�r�_binary_compiler�
�r�c

r�)r�cs�|�|
�
Srr�)r9rPr�r rrQ�
sz!_unary_compiler..r r�r r�r�_unary_compiler�
r�r�c


C�d
S)Nrr rOr r rrQ�
�rQc@s�eZ
dZd
Zdd�Zdd�Zdd�Zdd�Zdd�Zd d�Z d d�Z dd�Zed�
Z ed �
Zed�
Zed�
Zed�
Zed�
Zdd�ZdS)� _CompilerzZThe compilers are able to transform the expressions into multiple output formats. cCs|
\}}t|d
|�|�S)N�compile_)
�getattr)r9�argr��argsr r rrLs

z_Compiler.compilec


Cr�)Nrr rOr r rrQr�z_Compiler.c


Cr�)Nr r rOr r rrQr�c


Cr�)Nr&r rOr r rrQ r�c


Cr�)Nr'r rOr r rrQr�c


Cr�)Nr(r rOr r rrQr�c


Cr�)Nr)r rOr r rrQr�cCst|
�
Srr)rPr&r r rrQsz (%s && %s)z (%s || %s)z(!%s)z (%s %% %s)� (%s == %s)z (%s != %s)c
Cst��
r)
�NotImplementedError)r9r�r=rr r r�compile_relationrUz_Compiler.compile_relationN)rDr[r\r]rL� compile_n� compile_i� compile_v� compile_w� compile_f� compile_t� compile_valuer��compile_and� compile_orr��compile_not�compile_mod� compile_is� compile_isnotr�r r r rr�s"












r�c@s8eZ
dZd
Zed�
Zed�
Zed�
Zed�
Z dd�Z dS) rqz!Compiles an expression to Python.z(%s and %s)z (%s or %s)z(not %s)zMOD(%s, %s)cs8d
d��f
dd�|dD�
�
}d|
�
���|�
|fS)Nz[%s]r�c
s g|]}
dtt
�j|
��
�qS)
z(%s, %s))�tuple�maprL)r�range_rEr rrB's
�z4_PythonCompiler.compile_relation..r�z %s(%s, %s))r�upperrL)r9r�r=r�compile_range_listr rErr�%s


��
�z _PythonCompiler.compile_relationN)rDr[r\r]r�r�r�r�r�r�r�r r r rrqs



rqc@s.eZ
dZd
ZejZeZeZ eZ eZdd�ZdS)ryz)Compile into a gettext plural expression.c Cs~g}|�|�
}|d
D],}|d|d
kr$|�
d||�|d�
f�

qt|j|�\}}|�
d||||f�

qdd�|�
S)Nr�r
r�z(%s >= %s && %s <= %s)z(%s)z || )rLr8r�r)r9r�r=rr��item�min�maxr r rr�6s 






�




�z!_GettextCompiler.compile_relationN) rDr[r\r]r�r�r��compile_zeror�r�r�r�r�r r r rry-s




ryc@s0eZ
dZd
Zdd�ZeZeZeZeZ dd�Z dS)rbz/Compiles the expression to plain of JavaScript.c


Cr�)NzparseInt(n, 10)r rOr r rrQOr�z_JavaScriptCompiler.cCs4t�
||
||�}|
d
kr|�|�
}d|||f}|S)Nr�z(parseInt(%s, 10) == %s && %s))ryr�rL)r9r�r=rrur r rr�Us

�


z$_JavaScriptCompiler.compile_relationN)rDr[r\r]r�r�r�r�r�r�r�r r r rrbJs




rbc@sJeZ
dZd
Zed�
Zed�
Zed�
Zed�
Zed�
Z dd�Z d d d�
ZdS)rKz+Returns a unicode pluralization rule again.z%s is %sz%s is not %sz %s and %sz%s or %sz %s mod %scCs|j|
d
ddi
�
S)Nr�r�T)
r�)r9r�r r rr�ks
z_UnicodeCompiler.compile_notFcCsvg}|d
D]"}|d|d
kr|�|�
|d�
�

q|�dtt|j
|��
�

qd|�
|�
|r2dp3d|
d�|�
fS)Nr�r
z%s..%sz %s%s %s %sz notr r�)r8rLr�r�r)r9r�r=rr��rangesr�r r rr�ns






�z!_UnicodeCompiler.compile_relationN)
F)rDr[r\r]r�r�r�r�r�r�r�r�r r r rrK^s




rKr)&r]�re� babel._compatrr3rcr*�objectr+rgrYr|rnrorp� Exceptionr�r�rL�UNICODE�formatr�r�r�r�r�r�r�r�r6r�r�r�r�rqryrbrKr r r r�
sN
 
8](

�

�  {