def _get_plural_legacy(amount, extra_variants):
"""
Get proper case with value (legacy variant, without absence)
@param amount: amount of objects
@type amount: C{int} or C{long}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects, 5 objects, 0-object variant).
0-object variant is similar to C{absence} in C{get_plural}
@type variants: 3-element C{sequence} of C{unicode}
or C{unicode} (three variants with delimeter ',')
@return: amount with proper variant
@rtype: C{unicode}
"""
absence = None
if isinstance(extra_variants, unicode):
extra_variants = utils.split_values(extra_variants)
if len(extra_variants) == 4:
variants = extra_variants[:3]
absence = extra_variants[3]
else:
variants = extra_variants
return get_plural(amount, variants, absence)
def choose_plural_amount(amount, variants):
"""
Choose proper case depending on amount, for "N of M items" case
@param amount: amount of objects
@type amount: C{int} or C{long}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects).
@type variants: 2-element C{sequence} of C{unicode}
or C{unicode} (two variants with delimeter ',')
@return: proper variant
@rtype: C{unicode}
@raise L{pytils.err.InputParameterError}: input parameters' check failed
(amount isn't C{int}, variants isn't C{sequence})
@raise ValueError: amount is negative
@raise ValueError: variants' length lesser than 2
"""
if isinstance(variants, unicode):
variants = utils.split_values(variants)
check_length(variants, 2)
check_positive(amount)
amount_str = str(amount)
if amount == 1 or (amount_str[-1::] == "1" and amount_str[-2::] != "11"):
variant = 0
else:
variant = 1
return variants[variant]
def choose_plural(amount, variants):
"""
Choose proper case depending on amount
@param amount: amount of objects
@type amount: C{integer types}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects, 5 objects).
@type variants: 3-element C{sequence} of C{unicode}
or C{unicode} (three variants with delimeter ',')
@return: proper variant
@rtype: C{unicode}
@raise ValueError: variants' length lesser than 3
"""
if isinstance(variants, six.text_type):
variants = split_values(variants)
check_length(variants, 3)
amount = abs(amount)
if amount % 10 == 1 and amount % 100 != 11:
variant = 0
elif amount % 10 >= 2 and amount % 10 <= 4 and \
(amount % 100 < 10 or amount % 100 >= 20):
variant = 1
else:
variant = 2
return variants[variant]
def _get_plural_legacy(amount, extra_variants):
"""
Get proper case with value (legacy variant, without absence)
@param amount: amount of objects
@type amount: C{int} or C{long}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects, 5 objects, 0-object variant).
0-object variant is similar to C{absence} in C{get_plural}
@type variants: 3-element C{sequence} of C{unicode}
or C{unicode} (three variants with delimeter ',')
@return: amount with proper variant
@rtype: C{unicode}
"""
absence = None
if isinstance(extra_variants, unicode):
extra_variants = utils.split_values(extra_variants)
if len(extra_variants) == 4:
variants = extra_variants[:3]
absence = extra_variants[3]
else:
variants = extra_variants
return get_plural(amount, variants, absence)
def choose_plural(amount, variants):
"""
Choose proper case depending on amount
@param amount: amount of objects
@type amount: C{int} or C{long}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects, 5 objects).
@type variants: 3-element C{sequence} of C{unicode}
or C{unicode} (three variants with delimeter ',')
@return: proper variant
@rtype: C{unicode}
@raise L{pytils.err.InputParameterError}: input parameters' check failed
(amount isn't C{int}, variants isn't C{sequence})
@raise ValueError: variants' length lesser than 3
"""
if isinstance(variants, unicode):
variants = utils.split_values(variants)
check_length(variants, 3)
amount = abs(amount)
if amount % 10 == 1 and amount % 100 != 11:
variant = 0
elif amount % 10 >= 2 and amount % 10 <= 4 and \
(amount % 100 < 10 or amount % 100 >= 20):
variant = 1
else:
variant = 2
return variants[variant]
def choose_plural(amount, variants):
"""
Choose proper case depending on amount
@param amount: amount of objects
@type amount: C{int} or C{long}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects, 5 objects).
@type variants: 3-element C{sequence} of C{unicode}
or C{unicode} (three variants with delimeter ',')
@return: proper variant
@rtype: C{unicode}
@raise L{pytils.err.InputParameterError}: input parameters' check failed
(amount isn't C{int}, variants isn't C{sequence})
@raise ValueError: variants' length lesser than 3
"""
if isinstance(variants, unicode):
variants = utils.split_values(variants)
check_length(variants, 3)
amount = abs(amount)
if amount % 10 == 1 and amount % 100 != 11:
variant = 0
elif amount % 10 >= 2 and amount % 10 <= 4 and \
(amount % 100 < 10 or amount % 100 >= 20):
variant = 1
else:
variant = 2
return variants[variant]
def choose_plural(amount, variants):
"""
Choose proper case depending on amount
@param amount: amount of objects
@type amount: C{integer types}
@param variants: variants (forms) of object in such form:
(1 object, 2 objects, 5 objects).
@type variants: 3-element C{sequence} of C{unicode}
or C{unicode} (three variants with delimeter ',')
@return: proper variant
@rtype: C{unicode}
@raise ValueError: variants' length lesser than 3
"""
if isinstance(variants, six.text_type):
variants = split_values(variants)
check_length(variants, 3)
amount = abs(amount)
if amount % 10 == 1 and amount % 100 != 11:
variant = 0
elif amount % 10 >= 2 and amount % 10 <= 4 and \
(amount % 100 < 10 or amount % 100 >= 20):
variant = 1
else:
variant = 2
return variants[variant]
def sum_string(amount, gender, items=None):
"""
Get sum in words
@param amount: amount of objects
@type amount: C{integer types}
@param gender: gender of object (MALE, FEMALE or NEUTER)
@type gender: C{int}
@param items: variants of object in three forms:
for one object, for two objects and for five objects
@type items: 3-element C{sequence} of C{unicode} or
just C{unicode} (three variants with delimeter ',')
@return: in-words representation objects' amount
@rtype: C{unicode}
@raise ValueError: items isn't 3-element C{sequence} or C{unicode}
@raise ValueError: amount bigger than 10**36-1
@raise ValueError: amount is negative
"""
if isinstance(items, six.text_type):
items = split_values(items)
if items is None:
items = (u"", u"", u"")
try:
one_item, two_items, five_items = items
except ValueError:
raise ValueError("Items must be 3-element sequence")
check_positive(amount)
if amount == 0:
return u"ноль %s" % five_items
into = u''
tmp_val = amount
# единицы
into, tmp_val = _sum_string_fn(into, tmp_val, gender, items)
names = (
(FEMALE, (u"тысяча", u"тысячи", u"тысяч")), # тысячи
(MALE, (u"миллион", u"миллиона", u"миллионов")), # миллионы
(MALE, (u"миллиард", u"миллиарда", u"миллиардов")), # миллиарды
(MALE, (u"триллион", u"триллиона", u"триллионов")), # триллионы
(MALE, (u"квадриллион", u"квадриллиона", u"квадриллионов")), # квадриллионы
(MALE, (u"квинтиллион", u"квинтиллиона", u"квинтиллионов")), # квинтиллион
(MALE, (u"секстилион", u"секстилиона", u"секстилионов")), # секстилион
(MALE, (u"септиллион", u"септиллиона", u"септиллионов")), # септиллион
(MALE, (u"октиллион", u"октиллиона", u"октиллионов")), # октиллион
(MALE, (u"нониллион", u"нониллиона", u"нониллионов")), # нониллион
(MALE, (u"дециллион", u"дециллиона", u"дециллионов")), # дециллион
)
for name in names:
into, tmp_val = _sum_string_fn(into, tmp_val, *name)
if tmp_val == 0:
return into
raise ValueError("Cannot operand with numbers bigger than 10**36-1")
def get_plural_for_decimal(decimal, variants, absence=None):
if isinstance(variants, unicode):
variants = utils.split_values(variants)
utils.check_length(variants, 4)
if int(decimal) == decimal:
return u"%d %s   " % (decimal, choose_plural(int(decimal), variants[0:-1]))
else:
return u"%.2f %s" % (decimal, variants[-1])
def sum_string(amount, gender, items=None, case=NOMINATIVE):
"""
Get sum in words
@param amount: amount of objects
@type amount: C{integer types}
@param gender: gender of object (MALE, FEMALE or NEUTER)
@type gender: C{int}
@param gender: gender (NOMINATIVE or GENITIVE)
@type gender: C{int}
@param items: variants of object in three forms:
for one object, for two objects and for five objects
@type items: 3-element C{sequence} of C{unicode} or
just C{unicode} (three variants with delimeter ',')
@return: in-words representation objects' amount
@rtype: C{unicode}
@raise ValueError: items isn't 3-element C{sequence} or C{unicode}
@raise ValueError: amount bigger than 10**11
@raise ValueError: amount is negative
"""
if isinstance(items, six.text_type):
items = split_values(items)
if items is None:
items = (u"", u"", u"")
try:
one_item, two_items, five_items = items
except ValueError:
raise ValueError("Items must be 3-element sequence")
check_positive(amount)
if amount == 0:
return u"ноль %s" % five_items
into = u''
tmp_val = amount
# единицы
into, tmp_val = _sum_string_fn(into, tmp_val, gender, items, case=case)
# тысячи
into, tmp_val = _sum_string_fn(into, tmp_val, FEMALE,
(u"тысяча", u"тысячи", u"тысяч"), case=case)
# миллионы
into, tmp_val = _sum_string_fn(into, tmp_val, MALE,
(u"миллион", u"миллиона", u"миллионов"), case=case)
# миллиарды
into, tmp_val = _sum_string_fn(into, tmp_val, MALE,
(u"миллиард", u"миллиарда", u"миллиардов"), case=case)
if tmp_val == 0:
return into
else:
raise ValueError("Cannot operand with numbers bigger than 10**11")
def sum_string(amount, gender, items=None):
"""
Get sum in words
@param amount: amount of objects
@type amount: C{integer types}
@param gender: gender of object (MALE, FEMALE or NEUTER)
@type gender: C{int}
@param items: variants of object in three forms:
for one object, for two objects and for five objects
@type items: 3-element C{sequence} of C{unicode} or
just C{unicode} (three variants with delimeter ',')
@return: in-words representation objects' amount
@rtype: C{unicode}
@raise ValueError: items isn't 3-element C{sequence} or C{unicode}
@raise ValueError: amount bigger than 10**11
@raise ValueError: amount is negative
"""
if isinstance(items, six.text_type):
items = split_values(items)
if items is None:
items = (u"", u"", u"")
try:
one_item, two_items, five_items = items
except ValueError:
raise ValueError("Items must be 3-element sequence")
check_positive(amount)
if amount == 0:
if five_items:
return u"ноль %s" % five_items
else:
return u"ноль"
into = u''
tmp_val = amount
# единицы
into, tmp_val = _sum_string_fn(into, tmp_val, gender, items)
# тысячи
into, tmp_val = _sum_string_fn(into, tmp_val, FEMALE,
(u"тысяча", u"тысячи", u"тысяч"))
# миллионы
into, tmp_val = _sum_string_fn(into, tmp_val, MALE,
(u"миллион", u"миллиона", u"миллионов"))
# миллиарды
into, tmp_val = _sum_string_fn(into, tmp_val, MALE,
(u"миллиард", u"миллиарда", u"миллиардов"))
if tmp_val == 0:
return into
else:
raise ValueError("Cannot operand with numbers bigger than 10**11")
def sum_string(amount, gender, items=None):
"""
Get sum in words
@param amount: amount of objects
@type amount: C{int} or C{long}
@param gender: gender of object (MALE, FEMALE or NEUTER)
@type gender: C{int}
@param items: variants of object in three forms:
for one object, for two objects and for five objects
@type items: 3-element C{sequence} of C{unicode} or
just C{unicode} (three variants with delimeter ',')
@return: in-words representation objects' amount
@rtype: C{unicode}
@raise L{pytils.err.InputParameterError}: input parameters' check failed
@raise ValueError: items isn't 3-element C{sequence} or C{unicode}
@raise ValueError: amount bigger than 10**11
@raise ValueError: amount is negative
"""
if isinstance(items, str):
items = utils.split_values(items)
if items is None:
items = ("", "", "")
try:
one_item, two_items, five_items = items
except ValueError:
raise ValueError("Items must be 3-element sequence")
check_positive(amount)
if amount == 0:
return "ноль %s" % five_items
into = ''
tmp_val = amount
# единицы
into, tmp_val = _sum_string_fn(into, tmp_val, gender, items)
# тысячи
into, tmp_val = _sum_string_fn(into, tmp_val, FEMALE,
("тысяча", "тысячи", "тысяч"))
# миллионы
into, tmp_val = _sum_string_fn(into, tmp_val, MALE,
("миллион", "миллиона", "миллионов"))
# миллиарды
into, tmp_val = _sum_string_fn(into, tmp_val, MALE,
("миллиард", "миллиарда", "миллиардов"))
if tmp_val == 0:
return into
else:
raise ValueError("Cannot operand with numbers bigger than 10**11")
@type gender: C{int}
@param items: variants of object in three forms:
for one object, for two objects and for five objects
@type items: 3-element C{sequence} of C{unicode} or
just C{unicode} (three variants with delimeter ',')
@return: in-words representation objects' amount
@rtype: C{unicode}
@raise ValueError: items isn't 3-element C{sequence} or C{unicode}
@raise ValueError: amount bigger than 10**11
@raise ValueError: amount is negative
"""
if isinstance(items, six.text_type):
items = split_values(items)
if items is None:
items = (u"", u"", u"")
try:
one_item, two_items, five_items = items
except ValueError:
raise ValueError("Items must be 3-element sequence")
check_positive(amount)
if amount == 0:
return u"ноль %s" % five_items
into = u''
tmp_val = amount