3
HX@S @ s d Z ddlZddlmZ dFZd Zd
d ZG d d
d
eZdd Z dd Z
dd Z dd Z dd Z
dd ZG dd deZd Zdejd ejfd ejd jefd ejd!fd"ejd#fd$ejd%ejfgZd&d' ZdGd(d)ZdHd*d+Zd,d- Zd.d/ Zd0d1 Zd2d3 Z G d4d5 d5eZ d6d7 Z d8d9 Z d:d; Z G dd? d?e!Z"G d@dA dAe!Z#G dBdC dCe#Z$G dDdE dEe!Z%dS )Iz
babel.numbers
~~~~~~~~~~~~~
CLDR Plural support. See UTS #35.
:copyright: (c) 2013 by the Babel Team.
:license: BSD, see LICENSE for more details.
N)decimalzeroonetwofewmanyotherc C s t | }t|}t|tr6||kr(|}ntjt|}t|tjr|j }|j}|dk rf|j |d nf }dj
dd |D }|j d}t |}t |} t|pd}
t|pd} 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`: http://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 s s | ]}t |V qd S )N)str).0d r
/usr/lib/python3.6/plural.py A s z#extract_operands..0)
absint
isinstancefloatr ZDecimalr
Zas_tupleZexponentZdigitsjoinrstriplen) sourceniZ dec_tupleZexpZfraction_digitsZtrailingZ no_trailingvwftr
r
r extract_operands s$
r c @ sd e Zd ZdZdZdd Zdd Zedd Ze d
d Z
e d d
ddZ dd Z dd Z
dd ZdS )
PluralRuleae 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`: http://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Language_Plural_Rules
abstract_funcc C s t |tr|j }t }g | _xjtt|D ]Z\}}|tkrJtd| n||kr^td| |j | t
|j }|r,| jj ||f q,W 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
zunknown tag %rztag %r defined twiceN)
r dictitemssetr! sortedlist _plural_tags
ValueErroradd_Parserastappend)selfrulesfoundkeyexprr, r
r
r __init__c s
zPluralRule.__init__c s, | j dt| jdj fddtD f S )Nz<%s %r>z, c s$ g | ] }| krd | | f qS )z%s: %sr
)r tag)r/ r
r
} s z'PluralRule.__repr__..)r/ type__name__r r( )r. r
)r/ r __repr__y s zPluralRule.__repr__c C s 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 )clsr/ r
r
r parse s
zPluralRule.parsec s t j t fdd| jD S )zThe `PluralRule` as a dict of unicode plural rules.
>>> rule = PluralRule({'one': 'n is 1'})
>>> rule.rules
{'one': 'n is 1'}
c s g | ]\}}| |fqS r
r
)r r4 r, )_compiler
r r5 s z$PluralRule.rules..)_UnicodeCompilercompiler# r! )r. r
)r; r r/ s zPluralRule.rulesc C s t dd | jD S )Nc S s g | ] }|d qS )r r
)r r r
r
r r5 s z'PluralRule...) frozensetr! )xr
r
r s zPluralRule.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 C s | j S )N)r! )r. r
r
r __getstate__ s zPluralRule.__getstate__c C s
|| _ d S )N)r! )r. r! r
r
r __setstate__ s zPluralRule.__setstate__c C s t | dst| | _| j|S )Nr" )hasattr to_pythonr" )r. r r
r
r __call__ s
zPluralRule.__call__N)r! r" )r7
__module__ __qualname____doc__ __slots__r3 r8 classmethodr: propertyr/ tagsrB rC rF r
r
r
r r L s r c C sV t j}dg}x.tj| jD ] \}}|jd|||f q W |jdt dj|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 )_JavaScriptCompilerr= r r: r! r-
_fallback_tagr )ruleZto_jsresultr4 r, r
r
r
to_javascript s rR c C s t tttd}t j}ddg}x2tj| jD ]"\}}|j d||t
|f q,W |j dt tdj |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
)INZWITHINZMODr zdef evaluate(n):z' n, i, v, w, f, t = extract_operands(n)z if (%s): return %rz
return %r
zexecZevaluate)
in_range_listwithin_range_list cldr_modulor _PythonCompilerr= r r: r! r- r
rO r eval)rP namespaceZto_python_funcrQ r4 r, coder
r
r rE s
rE c s t j| } | jttgB t j} fddtD j}dt g}x,| j
D ]"\}}|j d||||f qLW |j d|t dj |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 s g | ]}| kr|qS r
r
)r r4 ) used_tagsr
r r5 s z to_gettext..znplurals=%d; plural=(z
%s ? %d : z%d)r )
r r: rM r% rO _GettextCompilerr= r( indexr r! r- r )rP r; Z
_get_indexrQ r4 r, r
)r] r
to_gettext s
r` c C s | t | kot| |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 rW )num
range_listr
r
r rV s rV c s t fdd|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 s" | ]\}} |ko |kV qd S )Nr
)r Zmin_Zmax_)ra r
r r $ s z$within_range_list..)any)ra rb r
)ra r rW s rW c C s@ d}| dk r| d9 } d}|dk r(|d9 }| | }|r<|d9 }|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 re re r
)abreverservr
r
r rX ' s rX c @ s e Zd ZdZdS ) RuleErrorz Raised if a rule is malformed.N)r7 rG rH rI r
r
r
r rj > s rj Znivwftz\s+wordz)\b(and|or|is|(?:with)?in|not|mod|[{0}])\bvaluez\d+symbolz%|,|!=|=ellipsisz\.{2,3}|\u2026c C s | j dd } g }d}t| }xb||k rxTtD ]<\}}|j| |}|d k r.|j }|rh|j||j f P q.W td| | q W |d d d S )N@r z5malformed CLDR pluralization rule. Got unexpected %rrd re )splitr _RULESmatchendr- grouprj )srQ posrs tokrP rr r
r
r
tokenize_ruleM s
rx c C s, | o*| d d |ko*|d kp*| d d |kS )Nrd r re re r
)tokenstype_rl r
r
r test_next_token` s r{ c C s t | ||r| j S d S )N)r{ pop)ry rz rl r
r
r
skip_tokene s r} c C s
d| ffS )Nrl r
)rl r
r
r
value_nodej s r~ c C s | f fS )Nr
)namer
r
r
ident_noden s r c C s d| fS )Nrb r
)rb r
r
r range_list_noder s r c C s
d| ffS )Nnotr
)ri r
r
r negatev s r c @ sb e Zd ZdZdd ZdddZdd Zd d
Zd d Zd
d Z dd Z
dd Z dd Z dd Z
dS )r+ 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 instanciation into an attribute
called `ast`.
c C sD t || _| jsd | _d S | j | _| jr@td| jd d d S )Nz Expected end of rule, got %rrd re )rx ry r, conditionrj )r. stringr
r
r r3 s
z_Parser.__init__Nc C sf t | j||}|d k r|S |d kr6t|d kr0|p2|}| jsHtd| td|| jd d f d S )Nz#expected %s but end of rule reachedzexpected %s but got %rrd re )r} ry reprrj )r. rz rl Ztermtokenr
r
r expect s z_Parser.expectc C s0 | j }x"t| jddr*d|| j ff}q
W |S )Nrk or)
and_conditionr} ry )r. opr
r
r r s z_Parser.conditionc C s0 | j }x"t| jddr*d|| j ff}q
W |S )Nrk and)relationr} ry )r. r r
r
r r s z_Parser.and_conditionc C s | j }t| jddr8t| jddr(dp*d|| j ffS t| jdd}d}t| jddr^d}n$t| jdds|rxtd| j|S d||| j ff}|rt|S |S ) Nrk isr ZisnotinZwithinz#Cannot negate operator based rules.r )r2 r} ry rl rj newfangled_relationrb r )r. leftnegatedmethodri r
r
r r s
z_Parser.relationc C sR t | jddrd}n t | jddr(d}ntddd|| j ff}|rNt|S |S ) Nrm =Fz!=Tz'Expected "=" or "!=" or legacy relationr r )r} ry rj rb r )r. r r ri r
r
r r s z_Parser.newfangled_relationc C s, | j }t| jdr || j fS ||fS d S )Nrn )rl r} ry )r. r r
r
r range_or_value s z_Parser.range_or_valuec C s4 | j g}x t| jddr*|j| j q W t|S )Nrm ,)r r} ry r- r )r. rb r
r
r rb s
z_Parser.range_listc C s| t | jd}|d ks |d tkr(td|d }t | jddrRd|f f| j ffS t | jddrtd|f f| j ffS t|S )Nrk rd z Expected identifier variablemodrm %)r} ry _VARSrj rl r )r. rk r r
r
r r2 s z _Parser.exprc C s t t| jdd S )Nrl rd )r~ r r )r. r
r
r rl s z
_Parser.value)NN)r7 rG rH rI r3 r r r r r r rb r2 rl r
r
r
r r+ z s
r+ c s fddS )z%Compiler factory for the `_Compiler`.c s | j || j |f S )N)r= )r. lr)tmplr
r r@ s z"_binary_compiler..r
)r r
)r r _binary_compiler s r c s fddS )z%Compiler factory for the `_Compiler`.c s | j | S )N)r= )r. r? )r r
r r@ s z!_unary_compiler..r
)r r
)r r _unary_compiler s r c C s dS )Nr r
)r? r
r
r r@ s r@ c @ s e Zd ZdZdd Zdd Zdd Zdd Zdd Zd d Z d
d Z
d d Z e d Z
e d
ZedZe dZe dZe dZdd ZdS ) _CompilerzZThe compilers are able to transform the expressions into multiple
output formats.
c C s |\}}t | d| | S )NZcompile_)getattr)r. argr argsr
r
r r= s z_Compiler.compilec C s dS )Nr r
)r? r
r
r r@ s z_Compiler.c C s dS )Nr r
)r? r
r
r r@ s c C s dS )Nr r
)r? r
r
r r@
s c C s dS )Nr r
)r? r
r
r r@ s c C s dS )Nr r
)r? r
r
r r@ s c C s dS )Nr r
)r? r
r
r r@ s c C s t |S )N)r
)r? r r
r
r r@ s z
(%s && %s)z
(%s || %s)z(!%s)z
(%s %% %s)z
(%s == %s)z
(%s != %s)c C s
t d S )N)NotImplementedError)r. r r2 rb r
r
r compile_relation s z_Compiler.compile_relationN)r7 rG rH rI r= compile_n compile_i compile_v compile_w compile_f compile_tZ
compile_valuer compile_and
compile_orr compile_not compile_mod
compile_is
compile_isnotr r
r
r
r r s r c @ s8 e Zd ZdZedZedZedZedZ dd Z
dS ) rY z!Compiles an expression to Python.z (%s and %s)z
(%s or %s)z(not %s)z MOD(%s, %s)c s8 ddj fdd|d D }d|j j||f S )Nz[%s]r c s g | ]}d t t j| qS )z(%s, %s))tuplemapr= )r Zrange_)r. r
r r5 ' s z4_PythonCompiler.compile_relation..rd z
%s(%s, %s))r upperr= )r. r r2 rb Zcompile_range_listr
)r. r r % s
z _PythonCompiler.compile_relationN) r7 rG rH rI r r r r r r r r
r
r
r rY s rY c @ s. e Zd ZdZejZeZeZ eZ
eZ dd Z dS )r^ z)Compile into a gettext plural expression.c C s g }| j |}xd|d D ]X}|d |d krJ|jd|| j |d f qt| j |\}}|jd||||f qW ddj| S )Nrd r z
(%s == %s)z(%s >= %s && %s <= %s)z(%s)z || )r= r- r r )r. r r2 rb ri itemminmaxr
r
r r 6 s
z!_GettextCompiler.compile_relationN)
r7 rG rH rI r r r compile_zeror r r r r r
r
r
r r^ - s r^ c @ s0 e Zd ZdZdd ZeZeZeZeZ dd Z
dS )rN z/Compiles the expression to plain of JavaScript.c C s dS )NzparseInt(n, 10)r
)r? r
r
r r@ O s z _JavaScriptCompiler.c C s4 t j| |||}|dkr0| j|}d|||f }|S )Nr z (parseInt(%s, 10) == %s && %s))r^ r r= )r. r r2 rb r\ r
r
r r U s
z$_JavaScriptCompiler.compile_relationN) r7 rG rH rI r r r r r r r r
r
r
r rN J s rN c @ sJ e Zd ZdZedZedZedZedZedZ dd Z
d
d
d Z d S )r< z+Returns a unicode pluralization rule again.z%s is %sz %s is not %sz %s and %sz%s or %sz %s mod %sc C s | j |d ddiS )Nrd r T)r )r. r r
r
r r k s z _UnicodeCompiler.compile_notFc C sz g }xP|d D ]D}|d |d kr8|j | j|d q|j dtt| j| qW d| j||rhdpjd|dj|f S )Nrd r z%s..%sz
%s%s %s %sz notr r )r- r= r r r )r. r r2 rb r Zrangesr r
r
r r n s z!_UnicodeCompiler.compile_relationN)F) r7 rG rH rI r r r r r r r r r
r
r
r r< ^ s r< )r r r r r r )N)N)&rI reZ
babel._compatr r( rO r objectr rR rE r` rV rW rX Exceptionrj r r= UNICODEformatrq rx r{ r} r~ r r r r+ r r r r rY r^ rN r< r
r
r
r
sH 8](
{