num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_HE.py

@@ -0,0 +1,314 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2003, Taro Ogawa.  All Rights Reserved.
+# Copyright (c) 2013, Savoir-faire Linux inc.  All Rights Reserved.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA 02110-1301 USA
+
+
+from __future__ import print_function, unicode_literals
+
+from .base import Num2Word_Base
+from .compat import to_s
+from .utils import get_digits, splitbyx
+
+ZERO = (u'אפס',)
+
+ONES = {
+    1: (u'אחת', u'אחד', u'אחת', u'אחד',
+        u'ראשונה', u'ראשון', u'ראשונות', u'ראשונים'),
+    2: (u'שתיים', u'שניים', u'שתי', u'שני',
+        u'שנייה', u'שני', u'שניות', u'שניים'),
+    3: (u'שלוש', u'שלושה', u'שלוש', u'שלושת',
+        u'שלישית', u'שלישי', u'שלישיות', u'שלישיים'),
+    4: (u'ארבע', u'ארבעה', u'ארבע', u'ארבעת',
+        u'רביעית', u'רביעי', u'רביעיות', u'רביעיים'),
+    5: (u'חמש', u'חמישה', u'חמש', u'חמשת',
+        u'חמישית', u'חמישי', u'חמישיות', u'חמישיים'),
+    6: (u'שש', u'שישה', u'שש', u'ששת',
+        u'שישית', u'שישי', u'שישיות', u'שישיים'),
+    7: (u'שבע', u'שבעה', u'שבע', u'שבעת',
+        u'שביעית', u'שביעי', u'שביעיות', u'שביעיים'),
+    8: (u'שמונה', u'שמונה', u'שמונה', u'שמונת',
+        u'שמינית', u'שמיני', u'שמיניות', u'שמיניים'),
+    9: (u'תשע', u'תשעה', u'תשע', u'תשעת',
+        u'תשיעית', u'תשיעי', u'תשיעיות', u'תשיעיים'),
+}
+
+TENS = {
+    0: (u'עשר', u'עשרה', u'עשר', u'עשרת',
+        u'עשירית', u'עשירי', u'עשיריות', u'עשיריים'),
+    1: (u'עשרה', u'עשר'),
+    2: (u'שתים עשרה', u'שנים עשר'),
+}
+
+TWENTIES = {
+    2: (u'עשרים',),
+    3: (u'שלושים',),
+    4: (u'ארבעים',),
+    5: (u'חמישים',),
+    6: (u'שישים',),
+    7: (u'שבעים',),
+    8: (u'שמונים',),
+    9: (u'תשעים',),
+}
+
+HUNDREDS = {
+    1: (u'מאה', u'מאת'),
+    2: (u'מאתיים',),
+    3: (u'מאות',)
+}
+
+THOUSANDS = {
+    1: (u'אלף',),
+    2: (u'אלפיים',),
+    3: (u'אלפים', 'אלפי'),
+}
+
+LARGE = {
+    1: (u'מיליון', u'מיליוני'),
+    2: (u'מיליארד', u'מיליארדי'),
+    3: (u'טריליון', u'טריליוני'),
+    4: (u'קוודריליון', u'קוודריליוני'),
+    5: (u'קווינטיליון', u'קווינטיליוני'),
+    6: (u'סקסטיליון', u'סקסטיליוני'),
+    7: (u'ספטיליון', u'ספטיליוני'),
+    8: (u'אוקטיליון', u'אוקטיליוני'),
+    9: (u'נוניליון', u'נוניליוני'),
+    10: (u'דסיליון', u'דסיליוני'),
+    11: (u'אונדסיליון', u'אונדסיליוני'),
+    12: (u'דואודסיליון', u'דואודסיליוני'),
+    13: (u'טרדסיליון', u'טרדסיליוני'),
+    14: (u'קווטואורדסיליון', u'קווטואורדסיליוני'),
+    15: (u'קווינדסיליון', u'קווינדסיליוני'),
+    16: (u'סקסדסיליון', u'סקסדסיליוני'),
+    17: (u'ספטנדסיליון', u'ספטנדסיליוני'),
+    18: (u'אוקטודסיליון', u'אוקטודסיליוני'),
+    19: (u'נובמדסיליון', u'נובמדסיליוני'),
+    20: (u'ויגינטיליון', u'ויגינטיליוני')
+}
+
+AND = u'ו'
+
+DEF = u'ה'
+
+MAXVAL = int('1' + '0' * 66)
+
+
+def chunk2word(n, i, x, gender='f', construct=False,
+               ordinal=False, plural=False):
+    words = []
+    n1, n2, n3 = get_digits(x)
+
+    if n3 > 0:
+        if construct and n == 100:
+            words.append(HUNDREDS[n3][1])
+        elif n3 <= 2:
+            words.append(HUNDREDS[n3][0])
+        else:
+            words.append(ONES[n3][0] + ' ' + HUNDREDS[3][0])
+
+    if n2 > 1:
+        words.append(TWENTIES[n2][0])
+
+    if i == 0 or x >= 11:
+        male = gender == 'm' or i > 0
+        cop = (2 * (construct and i == 0) + 4 *
+               ordinal + 2 * plural) * (n < 11)
+        if n2 == 1:
+            if n1 == 0:
+                words.append(TENS[n1][male + cop])
+            elif n1 == 2:
+                words.append(TENS[n1][male])
+            else:
+                words.append(ONES[n1][male] + ' ' + TENS[1][male])
+        elif n1 > 0:
+            words.append(ONES[n1][male + cop])
+
+    construct_last = construct and (n % 1000 ** i == 0)
+
+    if i == 1:
+        if x >= 11:
+            words[-1] = words[-1] + ' ' + THOUSANDS[1][0]
+        elif n1 == 0:
+            words.append(TENS[0][3] + ' ' + THOUSANDS[3][construct_last])
+        elif n1 <= 2:
+            words.append(THOUSANDS[n1][0])
+        else:
+            words.append(ONES[n1][3] + ' ' + THOUSANDS[3][construct_last])
+
+    elif i > 1:
+        if x >= 11:
+            words[-1] = words[-1] + ' ' + LARGE[i - 1][construct_last]
+        elif n1 == 0:
+            words.append(TENS[0][1 + 2 * construct_last] + ' ' +
+                         LARGE[i - 1][construct_last])
+        elif n1 == 1:
+            words.append(LARGE[i - 1][0])
+        else:
+            words.append(ONES[n1][1 + 2 * (construct_last or x == 2)] + ' ' +
+                         LARGE[i - 1][construct_last])
+
+    return words
+
+
+def int2word(n, gender='f', construct=False,
+             ordinal=False, definite=False, plural=False):
+    assert n == int(n)
+    assert not construct or not ordinal
+    assert ordinal or (not definite and not plural)
+    if n >= MAXVAL:
+        raise OverflowError('abs(%s) must be less than %s.' % (n, MAXVAL))
+
+    if n == 0:
+        if ordinal:
+            return DEF + ZERO[0]
+        return ZERO[0]
+
+    words = []
+
+    chunks = list(splitbyx(str(n), 3))
+    i = len(chunks)
+    for x in chunks:
+        i -= 1
+
+        if x == 0:
+            continue
+
+        words += chunk2word(n, i, x, gender=gender, construct=construct,
+                            ordinal=ordinal, plural=plural)
+
+        # https://hebrew-academy.org.il/2017/01/30/%D7%95-%D7%94%D7%97%D7%99%D7%91%D7%95%D7%A8-%D7%91%D7%9E%D7%A1%D7%A4%D7%A8%D7%99%D7%9D  # noqa
+        if len(words) > 1:
+            words[-1] = AND + words[-1]
+
+    if ordinal and (n >= 11 or definite):
+        words[0] = DEF + words[0]
+
+    return ' '.join(words)
+
+
+class Num2Word_HE(Num2Word_Base):
+    CURRENCY_FORMS = {
+        'ILS': ((u'שקל', u'שקלים'), (u'אגורה', u'אגורות')),
+        'EUR': ((u'אירו', u'אירו'), (u'סנט', u'סנטים')),
+        'USD': ((u'דולר', u'דולרים'), (u'סנט', u'סנטים')),
+    }
+
+    CURRENCY_GENDERS = {
+        'ILS': ('m', 'f'),
+        'EUR': ('m', 'm'),
+        'USD': ('m', 'm'),
+    }
+
+    def __init__(self, makaf='-'):
+        super(Num2Word_HE, self).__init__()
+        self.makaf = makaf
+
+    def setup(self):
+        super(Num2Word_HE, self).setup()
+        self.negword = u'מינוס'
+        self.pointword = u'נקודה'
+        self.MAXVAL = MAXVAL
+
+    def to_cardinal_float(self, value, gender='f'):
+        try:
+            float(value) == value
+        except (ValueError, TypeError, AssertionError, AttributeError):
+            raise TypeError(self.errmsg_nonnum % value)
+
+        float_value = float(value)
+        pre, post = self.float2tuple(float_value)
+
+        post = str(post)
+        post = '0' * (self.precision - len(post)) + post
+
+        out = [self.to_cardinal(pre, gender=gender)]
+        # Handle negative decimals when integer part is 0
+        if float_value < 0 and pre == 0:
+            out = [self.negword.strip()] + out
+
+        if self.precision:
+            out.append(self.title(self.pointword))
+
+        for i in range(self.precision):
+            curr = int(post[i])
+            out.append(to_s(self.to_cardinal(curr)))
+
+        return ' '.join(out)
+
+    def to_cardinal(self, value, gender='f', construct=False):
+        try:
+            assert int(value) == value
+        except (ValueError, TypeError, AssertionError):
+            # https://hebrew-academy.org.il/2019/12/03/%D7%A2%D7%9C-%D7%94%D7%91%D7%A2%D7%AA-%D7%94%D7%9E%D7%A1%D7%A4%D7%A8-%D7%94%D7%9E%D7%A2%D7%95%D7%A8%D7%91  # noqa
+            return self.to_cardinal_float(value, gender=gender)
+
+        out = ""
+        if value < 0:
+            value = abs(value)
+            out = "%s " % self.negword.strip()
+
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        return out + int2word(int(value), gender=gender, construct=construct)
+
+    def to_ordinal(self, value, gender='m', definite=False, plural=False):
+        self.verify_ordinal(value)
+
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        return int2word(int(value), gender=gender, ordinal=True,
+                        definite=definite, plural=plural)
+
+    def pluralize(self, n, forms, currency=None, prefer_singular=False):
+        assert n == int(n)
+        form = 1
+        if n == 1 or prefer_singular and (
+                abs(n) >= 11 or n == 0 or currency != 'ILS'):
+            form = 0
+        return forms[form]
+
+    def to_currency(self, val, currency='ILS', cents=True,
+                    separator=AND, adjective=False,
+                    prefer_singular=False, prefer_singular_cents=False):
+        # Handle integers specially - just add currency name without cents
+        if isinstance(val, int):
+            # Get the result as if it were a float
+            result = super().to_currency(float(val), currency=currency,
+                                         cents=cents, separator=separator,
+                                         adjective=adjective)
+            # Remove zero cents patterns
+            zero_patterns = [
+                'zero cent', 'nul cent', 'null cent', 'sıfır kuruş',
+                'אפס אגורות', 'zero sen', 'ศูนย์สตางค์', 'không xu',
+                'शून्य पैसे', 'শূন্য পয়সা', 'nula lipa', 'нула пара',
+                'ноль копеек', 'нула стотинки', '零分', 'ዜሮ ሳንቲም',
+                'صفر', 'sero sent', 'dim ceiniog', 'ნულოვანი თეთრი',
+                'нула стотинки'
+            ]
+            import re
+            for pattern in zero_patterns:
+                if pattern in result.lower():
+                    # Remove the pattern and any connecting words
+                    result = re.sub(r'\s+(and|və|և|და|ir|და|და|و|و|与|ja|और|এবং|i|и|и|と|그리고|และ|và|dan|a|e|და)\s+' +
+                                    re.escape(pattern), '', result, flags=re.IGNORECASE)
+                    result = re.sub(re.escape(pattern), '', result, flags=re.IGNORECASE)
+                    result = ' '.join(result.split())  # Clean up extra spaces
+            return result.strip()
+
+        # For floats, call parent implementation
+        return super().to_currency(val, currency=currency, cents=cents,
+                                   separator=separator, adjective=adjective)

num2words2/lang_HI.py

@@ -0,0 +1,243 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2003, Taro Ogawa.  All Rights Reserved.
+# Copyright (c) 2013, Savoir-faire Linux inc.  All Rights Reserved.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA 02110-1301 USA
+
+from __future__ import unicode_literals
+
+import string
+
+from num2words2.base import Num2Word_Base
+
+
+class Num2Word_HI(Num2Word_Base):
+    """
+    Hindi (HI) Num2Word class
+    """
+
+    CURRENCY_FORMS = {
+        'INR': (('रुपया', 'रुपये'), ('पैसा', 'पैसे')),
+        'USD': (('डॉलर', 'डॉलर'), ('सेंट', 'सेंट')),
+        'EUR': (('यूरो', 'यूरो'), ('सेंट', 'सेंट')),
+    }
+
+    _irregular_ordinals = {
+        0: "शून्य",
+        1: "पहला",
+        2: "दूसरा",
+        3: "तीसरा",
+        4: "चौथा",
+        6: "छठा",
+    }
+    _irregular_ordinals_nums = {
+        0: "०",
+        1: "१ला",
+        2: "२रा",
+        3: "३रा",
+        4: "४था",
+        6: "६ठा",
+    }
+    _hindi_digits = "०१२३४५६७८९"  # 0-9
+    _digits_to_hindi_digits = dict(zip(string.digits, _hindi_digits))
+    _regular_ordinal_suffix = "वाँ"
+
+    def setup(self):
+        # Note: alternative forms are informal
+        self.low_numwords = [
+            "निन्यानवे",
+            "अट्ठानवे",
+            "सत्तानवे",  # alternative "सतानवे"
+            "छियानवे",
+            "पचानवे",
+            "चौरानवे",
+            "तिरानवे",
+            "बानवे",
+            "इक्यानवे",
+            "नब्बे",
+            "नवासी",
+            "अट्ठासी",
+            "सतासी",
+            "छियासी",
+            "पचासी",
+            "चौरासी",
+            "तिरासी",
+            "बयासी",
+            "इक्यासी",
+            "अस्सी",
+            "उनासी",  # alternative "उन्नासी"
+            "अठहत्तर",  # alternative "अठहतर"
+            "सतहत्तर",  # alternative "सतहतर"
+            "छिहत्तर",  # alternative "छिहतर"
+            "पचहत्तर",  # alternative "पचहतर"
+            "चौहत्तर",  # alternative "चौहतर"
+            "तिहत्तर",  # alternative "तिहतर"
+            "बहत्तर",  # alternative "बहतर"
+            "इकहत्तर",  # alternative "इकहतर"
+            "सत्तर",
+            "उनहत्तर",  # alternative "उनहतर"
+            "अड़सठ",  # alternative "अड़सठ"
+            "सड़सठ",  # alternative "सड़सठ"
+            "छियासठ",
+            "पैंसठ",
+            "चौंसठ",
+            "तिरसठ",
+            "बासठ",
+            "इकसठ",
+            "साठ",
+            "उनसठ",
+            "अट्ठावन",  # alternative "अठावन"
+            "सत्तावन",  # alternative "सतावन"
+            "छप्पन",
+            "पचपन",
+            "चौवन",
+            "तिरेपन",  # alternative "तिरपन"
+            "बावन",
+            "इक्यावन",
+            "पचास",
+            "उनचास",
+            "अड़तालीस",  # alternative "अड़तालीस"
+            "सैंतालीस",
+            "छियालीस",  # alternative "छयालिस"
+            "पैंतालीस",
+            "चौवालीस",  # alternative "चवालीस"
+            "तैंतालीस",  # alternative "तैतालीस"
+            "बयालीस",
+            "इकतालीस",
+            "चालीस",
+            "उनतालीस",
+            "अड़तीस",  # alternative "अड़तीस"
+            "सैंतीस",
+            "छत्तीस",  # alternative "छतीस"
+            "पैंतीस",
+            "चौंतीस",
+            "तैंतीस",
+            "बत्तीस",  # alternative "बतीस"
+            "इकत्तीस",  # alternative "इकतीस"
+            "तीस",
+            "उनतीस",
+            "अट्ठाईस",  # alternative "अट्ठाइस"
+            "सत्ताईस",  # alternative "सताइस"
+            "छब्बीस",
+            "पच्चीस",
+            "चौबीस",
+            "तेईस",  # alternative "तेइस"
+            "बाईस",
+            "इक्कीस",  # alternative "इकीस"
+            "बीस",
+            "उन्नीस",
+            "अट्ठारह",  # alternative "अठारह"
+            "सत्रह",
+            "सोलह",
+            "पंद्रह",
+            "चौदह",
+            "तेरह",
+            "बारह",
+            "ग्यारह",
+            "दस",
+            "नौ",
+            "आठ",
+            "सात",
+            "छः",  # alternative "छह"
+            "पाँच",  # alternative "पांच"
+            "चार",
+            "तीन",
+            "दो",
+            "एक",
+            "शून्य",
+        ]
+
+        self.mid_numwords = [(100, "सौ")]
+        self.high_numwords = [
+            (11, "ख़रब"),
+            (9, "अरब"),
+            (7, "करोड़"),  # alternative "करोड़"
+            (5, "लाख"),
+            (3, "हज़ार"),  # alternative "हज़ार"
+        ]
+        self.pointword = "दशमलव"
+        self.negword = "माइनस "
+
+    def set_high_numwords(self, high):
+        for n, word in self.high_numwords:
+            self.cards[10**n] = word
+
+    def merge(self, lpair, rpair):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+        # Remove "एक" prefix for certain major units (but keep for हज़ार)
+        if lnum == 1 and rnum in [100, 100000, 10000000]:  # सौ, लाख, करोड़ (but not हज़ार)
+            return rtext, rnum
+        elif lnum == 1 and rnum < 100:
+            return rtext, rnum
+        elif lnum >= 100 > rnum:
+            return "%s %s" % (ltext, rtext), lnum + rnum
+        elif rnum > lnum:
+            return "%s %s" % (ltext, rtext), lnum * rnum
+        return "%s %s" % (ltext, rtext), lnum + rnum
+
+    def pluralize(self, count, forms):
+        """Return the proper plural form for Hindi"""
+        if count == 1:
+            return forms[0]
+        return forms[1] if len(forms) > 1 else forms[0]
+
+    def to_currency(self, val, currency='INR', cents=True, separator=',',
+                    adjective=False):
+        # Handle integers specially - just add currency name without cents
+        if isinstance(val, int):
+            try:
+                cr1, cr2 = self.CURRENCY_FORMS[currency]
+            except (KeyError, AttributeError):
+                # Fallback to base implementation for unknown currency
+                return super(Num2Word_HI, self).to_currency(
+                    val, currency=currency, cents=cents, separator=separator,
+                    adjective=adjective)
+
+            minus_str = self.negword if val < 0 else ""
+            abs_val = abs(val)
+            money_str = self.to_cardinal(abs_val)
+
+            # Proper pluralization for currency
+            if abs_val == 1:
+                currency_str = cr1[0] if isinstance(cr1, tuple) else cr1
+            else:
+                currency_str = cr1[1] if isinstance(cr1, tuple) and len(cr1) > 1 else (cr1[0] if isinstance(cr1, tuple) else cr1)
+
+            return (u'%s %s %s' % (minus_str, money_str, currency_str)).strip()
+
+        # For floats, use the parent class implementation
+        return super(Num2Word_HI, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+
+    def to_ordinal(self, value):
+        if value in self._irregular_ordinals:
+            return self._irregular_ordinals[value]
+
+        # regular Hindi ordinals are derived from cardinals
+        # by modifying the last member of the expression.
+        cardinal = self.to_cardinal(value)
+        return cardinal + self._regular_ordinal_suffix
+
+    def _convert_to_hindi_numerals(self, value):
+        return "".join(map(self._digits_to_hindi_digits.__getitem__,
+                           str(value)))
+
+    def to_ordinal_num(self, value):
+        if value in self._irregular_ordinals_nums:
+            return self._irregular_ordinals_nums[value]
+
+        return self._convert_to_hindi_numerals(value) \
+            + self._regular_ordinal_suffix