/usr/lib/python2.6/site-packages/babel
Edit: /usr/lib/python2.6/site-packages/babel/plural.pyc (20189B)
Ñò
zDVc @ s d Z d d k Z d! Z d Z d e f d
„ ƒ YZ d „ Z d „ Z d
„ Z d „ Z d „ Z
d „ Z d e f d „ ƒ YZ
d e f d „ ƒ YZ d „ Z d „ Z d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d e f d „ ƒ YZ d S(" s«
babel.numbers
~~~~~~~~~~~~~
CLDR Plural support. See UTS #35.
:copyright: (c) 2013 by the Babel Team.
:license: BSD, see LICENSE for more details.
iÿÿÿÿNt zerot onet twot fewt manyt othert
PluralRulec B st e Z d Z d
Z d „ Z d „ Z e d „ ƒ Z e d „ ƒ Z e d „ d d ƒZ
d
„ Z d „ Z d „ Z
RS( s÷ 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.
t abstractt _funcc C sÇ t | t ƒ o | i ƒ } n t ƒ } g | _ xŽ t t | ƒ ƒ D]z \ } } | t j o t d | ƒ ‚ n" | | j o t d | ƒ ‚ n | i | ƒ | i i
| t | ƒ i f ƒ qE Wd S( s$ 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
s unknown tag %rs tag %r defined twiceN(
t
isinstancet dictt itemst setR t sortedt listt _plural_tagst
ValueErrort addt appendt _Parsert ast( t selft rulest foundt keyt expr( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt __init__( s
c
C sc | i } d t | ƒ i d i g } t D], } | | j o | d | | | f q) q) ~ ƒ f S( Ns <%s %r>s , s %s: %s( R t typet __name__t joinR ( R R t _[1]t tag( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt __repr__< s
c C s t | | ƒ o | S| | ƒ S( s
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 ( t clsR ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt parseD s c C sF t ƒ i } t g } | i D] \ } } | | | | ƒ f q ~ ƒ S( sŸ The `PluralRule` as a dict of unicode plural rules.
>>> rule = PluralRule({'one': 'n is 1'})
>>> rule.rules
{'one': 'n is 1'}
( t _UnicodeCompilert compileR
R ( R t _compileR R R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR P s c C s, t g } | i D] } | | d q ~ ƒ S( i ( t frozensetR ( t xR t i( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt
[ s t docs°
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.c C s | i S( N( R ( R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt __getstate__` s c C s
| | _ d S( N( R ( R R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt __setstate__c s c C s0 t | d ƒ p t | ƒ | _ n | i | ƒ S( NR ( t hasattrt to_pythonR ( R t n( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt __call__f s ( s abstracts _func( R t
__module__t __doc__t __slots__R R t classmethodR" t propertyR t tagsR+ R, R0 ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR s c C ss t ƒ i } d g } x= t i | ƒ i D]) \ } } | i d | | ƒ | f ƒ q( W| i d t ƒ d i | ƒ S( s‚ 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
s (function(n) { return s
%s ? %r : s %r; })t ( t _JavaScriptCompilerR$ R R" R R t
_fallback_tagR ( t rulet to_jst resultR R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt
to_javascriptl s !c C s· h t d 6t d 6t d 6} t ƒ i } d g } xC t i | ƒ i D]/ \ } } | i d | | ƒ t | ƒ f ƒ qC W| i d t
ƒ t d i | ƒ d d ƒ } t | | ƒ | d
S( s< 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
t INt WITHINt MODs def evaluate(n):s if (%s): return %rs
return %rs
s t exect evaluate(
t
in_range_listt within_range_listt cldr_modulot _PythonCompilerR$ R R" R R t strR9 R t eval( R: t namespaceR. R< R R t code( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR. ƒ s
'
c C sÚ t i | ƒ } | i t t g ƒ B} t ƒ i } g } t D] } | | j o | | q< q< ~ i } d t | ƒ g } x: | i
D]/ \ } } | i d | | ƒ | | ƒ f ƒ qƒ W| i d | t ƒ ƒ d i | ƒ S( s~ 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
s nplurals=%d; plural=(s
%s ? %d : s %d)R7 (
R R" R6 R R9 t _GettextCompilerR$ R t indext lenR R R ( R: t used_tagsR% R R t
_get_indexR< R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt
to_gettext§ s
5
'c C s | t | ƒ j o
t | | ƒ S( s™ 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
( t intRD ( t numt
range_list( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRC ¾ s c s t ‡ f d † | Dƒ ƒ S( s¶ 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 s2 x+ | ]$ \ } } ˆ | j o
ˆ | j Vq Wd S( N( ( t .0t min_t max_( RR ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pys ã s ( t any( RR RS ( ( RR s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRD Ò s c C se d } | d j o | d 9} d } n | d j o | d 9} n | | } | o | d 9} n | S( sî 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
i iÿÿÿÿi ( ( t at bt reverset rv( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRE æ s
t RuleErrorc B s e Z d Z RS( s Raised if a rule is malformed.( R R1 R2 ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR\ ý s R c B sÝ e Z d Z d e i d ƒ f d e i d ƒ f d e i d ƒ f d e i d ƒ f d e i d ƒ f g Z d
„ Z d d „ Z d d „ Z d d d
„ Z
d „ Z d „ Z d „ Z
d „ Z d „ Z d „ Z d „ Z RS( s… 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)*
and_condition = relation ('and' relation)*
relation = is_relation | in_relation | within_relation | 'n'
is_relation = expr 'is' ('not')? value
in_relation = expr ('not')? 'in' range_list
within_relation = expr ('not')? 'within' range_list
expr = 'n' ('mod' value)?
range_list = (range | value) (',' range_list)*
value = digit+
digit = 0|1|2|3|4|5|6|7|8|9
range = 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'.
The translator parses the expression on instanciation into an attribute
called `ast`.
s \s+(?u)t words% \b(and|or|is|(?:with)?in|not|mod|n)\bt values \d+t commat ,t ellipsiss \.\.c C s
| i ƒ } g } d } t | ƒ } x” | | j o† x | i D]` \ } } | i | | ƒ } | d j o5 | i ƒ } | o | i | | i ƒ f ƒ n Pq> q> Wt d | | ƒ ‚ q' W| d d d … | _ | i
ƒ | _ | i o t d | i d d ƒ ‚ n d S( Ni s5 malformed CLDR pluralization rule. Got unexpected %riÿÿÿÿs Expected end of rule, got %ri ( t lowerRM t _rulest matcht Nonet endR t groupR\ t tokenst conditionR ( R t stringR< t posRf t tokR: Rd ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR $ s*
c C sD | i o: | i d d | j o" | d j p | i d d | j S( Niÿÿÿÿi i ( Rh Re ( R R R^ ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt test; s "c C s% | i | | ƒ o | i i ƒ Sd S( N( Rm Rh t pop( R R R^ ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt skip? s c C s˜ | i | | ƒ } | d j o | S| d j o$ t | d j o | p | ƒ } n | i p t d | ƒ ‚ n t d | | i d d f ƒ ‚ d S( Ns# expected %s but end of rule reacheds expected %s but got %riÿÿÿÿi ( Ro Re t reprRh R\ ( R R R^ t termt token( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt expectC s
$
c C sC | i ƒ } x0 | i d d ƒ o d | | i ƒ f f } q W| S( NR] t or( t
and_conditionRo ( R t op( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRi M s
c C sC | i ƒ } x0 | i d d ƒ o d | | i ƒ f f } q W| S( NR] t and( t relationRo ( R Rv ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRu S s
c C sÔ | i ƒ } | i d d ƒ o1 | i d d ƒ o d p d | | i ƒ f f S| i d d ƒ } d } | i d d ƒ o
d } n | i d d d d ƒd | | | i ƒ f f } | o d | f f } n | S(
NR] t ist nott isnott int withinRq s 'within' or 'in'Rx ( R Ro R^ Rs RS ( R t leftt negatedt methodR[ ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRx Y s
c C s; | i ƒ } | i d ƒ o | | i ƒ f S| | f Sd S( NRa ( R^ Ro ( R R~ ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt range_or_valuei s c C sD | i ƒ g } x( | i d ƒ o | i | i ƒ ƒ q Wd | f S( NR_ RS ( R Ro R ( R RS ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRS p s
c C sJ | i d d ƒ | i d d ƒ o d d d f | i ƒ f f Sd d f S( NR] R/ t mod( ( ( Rs Ro R^ ( R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR v s c C s d t | i d ƒ d ƒ f f S( NR^ i ( RQ Rs ( R ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR^ | s N( R R1 R2 Re t reR$ Rc R Rm Ro Rs Ri Ru Rx R RS R R^ ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR s"
c s
‡ f d † S( s% Compiler factory for the `_Compiler`.c s ˆ | i | ƒ | i | ƒ f S( ( R$ ( R t lt r( t tmpl( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR) ‚ s ( ( R† ( ( R† s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt _binary_compiler€ s c s
‡ f d † S( s% Compiler factory for the `_Compiler`.c s ˆ | i | ƒ S( ( R$ ( R R' ( R† ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR) ‡ s ( ( R† ( ( R† s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt _unary_compiler… s t _Compilerc B sz e Z d Z d „ Z d „ Z d „ Z e d ƒ Z e d ƒ Z e d ƒ Z
e d ƒ Z e d ƒ Z e d ƒ Z
d
„ Z RS( sZ The compilers are able to transform the expressions into multiple
output formats.
c C s# | \ } } t | d | ƒ | Œ S( Nt compile_( t getattr( R t argRv t args( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR$ s c C s d S( R/ ( ( R' ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR) “ s c C s
t | ƒ S( ( RG ( R' t v( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR) ” s s
(%s && %s)s
(%s || %s)s (!%s)s
(%s %% %s)s
(%s == %s)s
(%s != %s)c C s
t ƒ ‚ d S( N( t NotImplementedError( R R€ R RS ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt compile_relationœ s ( R R1 R2 R$ t compile_nt
compile_valueR‡ t compile_andt
compile_orRˆ t compile_nott compile_modt
compile_ist
compile_isnotR ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR‰ Š s RF c B sG e Z d Z e d ƒ Z e d ƒ Z e d ƒ Z e d ƒ Z d „ Z RS( s! Compiles an expression to Python.s (%s and %s)s
(%s or %s)s (not %s)s MOD(%s, %s)c
C sh d d i g } | d D]# } | d t t | i | ƒ ƒ q ~ ƒ } d | i ƒ | i | ƒ | f S( Ns [%s]R` i s (%s, %s)s
%s(%s, %s)( R t tuplet mapR$ t upper( R R€ R RS R t range_t compile_range_list( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR ¨ s
8(
R R1 R2 R‡ R“ R” Rˆ R• R– R ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRF s RK c B s e Z d Z d „ Z RS( s) Compile into a gettext plural expression.c C s g } | i | ƒ } x„ | d D]x } | d | d j o( | i d | | i | d ƒ f ƒ q t | i | ƒ \ } } | i d | | | | f ƒ q Wd d i | ƒ S( Ni i s
(%s == %s)s (%s >= %s && %s <= %s)s (%s)s || ( R$ R Rš R ( R R€ R RS R[ t itemt mint max( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR ³ s ( R R1 R2 R ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyRK ° s R8 c B s e Z d Z d „ Z RS( s/ Compiles the expression to plain of JavaScript.c C sO t i | | | | ƒ } | d j o& | i | ƒ } d | | | f } n | S( NR| s (parseInt(%s) == %s && %s)( RK R R$ ( R R€ R RS RJ ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR Ê s
( R R1 R2 R ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR8 Ç s R# c B s_ e Z d Z e d ƒ Z e d ƒ Z e d ƒ Z e d ƒ Z e d ƒ Z d „ Z e
d „ Z RS( s+ Returns a unicode pluralization rule again.s %s is %ss %s is not %ss %s and %ss %s or %ss %s mod %sc C s | i d t | d Œ S( NR i ( R t True( R Rx ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR• Ü s c C s¥ g } xh | d D]\ } | d | d j o | i | i | d ƒ ƒ q | i d t t | i | ƒ ƒ ƒ q Wd | i | ƒ | o d p d | d i | ƒ f S( Ni i s %s..%ss
%s%s %s %ss notR7 R` ( R R$ R™ Rš R ( R R€ R RS R t rangesRž ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR ß s ' ( R R1 R2 R‡ R— R˜ R“ R” R– R• t FalseR ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyR# Ó s ( R R R R R s other( R2 Rƒ R R9 t objectR R= R. RP RC RD RE t ExceptionR\ R R‡ Rˆ R‰ RF RK R8 R# ( ( ( s+ /tmp/pip-build-lt8jXN/Babel/babel/plural.pyt
s& Y $