num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_CY.py

@@ -0,0 +1,574 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2023, Johannes Heinecke.  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
+
+from .lang_EUR import Num2Word_EUR
+
+# Welsh numerals differs to many other languages since the counted
+# object does not follow the numeral but is inserted between
+# e.g. "23 hours" is
+#   tri awr ar hugain
+#   3   hour on twenty
+# in addition to that some numeral trigger a mutation on the following word
+# either another numeral or the counted object
+# (https://en.wikipedia.org/wiki/Consonant_mutation#Welsh)
+# e.g. "23 dogs" (aspirated mutation, c -> ch)
+#  tri chi ar hugain
+#  3   dog on twenty
+# but "22 dogs" (soft mutation, c -> g)
+#  dau gi  ar hugain
+#  2   dog on twenty
+# and "24 dogs" (no mutation)
+#  pedwar ci ar hugain
+#  4      dog on twenty
+# (BTW, the counted word is always in singular when following a numeral)
+# numerals are mutated as well
+# e.g. "300"
+#    tri chant
+#    3   hundred
+# "200"
+#    dau gant
+#    2   hundred
+# "500"
+#    pump cant
+#    5    hundreds
+# the numerals for 2, 3 and 4 are different in function of gender (MASC, FEM)
+#    2 cats
+#    dwy gath
+
+#    2 dogs
+#    dau gi
+
+#    2000
+#    dwy fil
+
+#    3000
+#    tair mil
+
+# to add the counted object in the correct position use
+#   num2words(17, lang="cy", counted="ci", gender="masc")
+#   num2words(17, lang="cy", counted="cath", gender="fem")
+# if the number is > 99, use plural form of counted object
+#   num2words(117, lang="cy", counted="cathod", gender="fem")
+
+
+# Globals
+# -------
+
+OBJ = "__OBJECT__"
+
+CARDINAL_WORDS = {
+    # masc, fem, triggers mutation
+    0: [("dim", None), (OBJ, None)],
+    1: [("un", None), (OBJ, None)],
+    2: [("dau", "SM"), (OBJ, None)],
+    3: [("tri", "AM"), (OBJ, None)],
+    4: [("pedwar", None), (OBJ, None)],
+    5: [("pump", None), (OBJ, None)],
+    6: [("chwech", "AM"), (OBJ, None)],
+    7: [("saith", None), (OBJ, None)],
+    8: [("wyth", None), (OBJ, None)],
+    9: [("naw", None), (OBJ, None)],
+    10: [("deg", None), (OBJ, None)],
+    11: [("un", None), (OBJ, None), ("ar ddeg", None)],
+    12: [("deuddeg", None), (OBJ, None)],
+    13: [("tri", "AM"), (OBJ, None), ("ar ddeg", None)],
+    14: [("pedwar", None), (OBJ, None), ("ar ddeg", None)],
+    15: [("pymtheg", None), (OBJ, None)],
+    16: [("un", None), (OBJ, None), ("ar bymtheg", None)],
+    17: [("dau", "SM"), (OBJ, None), ("ar bymtheg", None)],
+    18: [("deunaw", None), (OBJ, None)],
+    19: [("pedwar", None), ("ar bymtheg", None)],
+}
+
+CARDINAL_WORDS_FEM = {
+    # masc, fem, triggers mutation
+    0: [("dim", None), (OBJ, None)],
+    1: [("un", None), (OBJ, None)],
+    2: [("dwy", "SM"), (OBJ, None)],
+    3: [("tair", None), (OBJ, None)],
+    4: [("pedair", None), (OBJ, None)],
+    5: [("pump", None), (OBJ, None)],
+    6: [("chwech", "AM"), (OBJ, None)],
+    7: [("saith", None), (OBJ, None)],
+    8: [("wyth", None), (OBJ, None)],
+    9: [("naw", None), (OBJ, None)],
+    10: [("deg", None), (OBJ, None)],
+    11: [("un", None), (OBJ, None), ("ar ddeg", None)],
+    12: [("deuddeg", None), (OBJ, None)],
+    13: [("tair", None), (OBJ, None), ("ar ddeg", None)],
+    14: [("pedair", None), (OBJ, None), ("ar ddeg", None)],
+    15: [("pymtheg", None), (OBJ, None)],
+    16: [("un", None), (OBJ, None), ("ar bymtheg", None)],
+    17: [("dwy", "SM"), (OBJ, None), ("ar bymtheg", None)],
+    18: [("deunaw", None), (OBJ, None)],
+    19: [("pedair", None), ("ar bymtheg", None)],
+}
+
+MILLION_WORDS = {
+    3: ("mil", None),
+    6: ("miliwn", None),
+    9: ("biliwn", None),
+    12: ("triliwn", None),
+    15: ("cwadriliwn", None),
+    18: ("cwintiliwn", None),
+    21: ("secsttiliwn", None),
+    24: ("septiliwn", None),
+    27: ("octiliwn", None),
+    30: ("noniliwn", None),
+    33: ("dengiliwn", None),
+}
+
+ORDINAL_WORDS = {
+    0: [("dimfed", None), (OBJ, None)],
+    1: [(OBJ, None), ("cyntaf", None)],
+    2: [("ail", "SM"), (OBJ, None)],
+    3: [("trydydd", None), (OBJ, None)],
+    4: [("pedwerydd", None), (OBJ, None)],
+    5: [("pumed", None), (OBJ, None)],
+    6: [("chweched", None), (OBJ, None)],
+    7: [("saithfed", None), (OBJ, None)],
+    8: [("wythfed", None), (OBJ, None)],
+    9: [("nawfed", None), (OBJ, None)],
+    10: [("degfed", None), (OBJ, None)],
+    11: [("unfed", "SM"), (OBJ, None), ("ar ddeg", None)],
+    12: [("deuddegfed", None), (OBJ, None)],
+    13: [("trydydd", None), (OBJ, None), ("ar ddeg", None)],
+    14: [("pedwerydd", None), (OBJ, None), ("ar ddeg", None)],
+    15: [("pymthegfed", None), (OBJ, None)],
+    16: [("unfed", None), (OBJ, None), ("ar bymtheg", None)],
+    17: [("ail", "SM"), (OBJ, None), ("ar bymtheg", None)],
+    18: [("deunawfed", None), (OBJ, None)],
+    19: [("pedwerydd", None), (OBJ, None), ("ar bymtheg", None)],
+}
+ORDINAL_WORDS_FEM = {
+    0: [("dimfed", None), (OBJ, None)],
+    1: [(OBJ, None), ("gyntaf", None)],
+    2: [("ail", "SM"), (OBJ, None)],
+    3: [("trydedd", "SM"), (OBJ, None)],
+    4: [("pedwaredd", "SM"), (OBJ, None)],
+    5: [("pumed", None), (OBJ, None)],
+    6: [("chweched", None), (OBJ, None)],
+    7: [("saithfed", None), (OBJ, None)],
+    8: [("wythfed", None), (OBJ, None)],
+    9: [("nawfed", None), (OBJ, None)],
+    10: [("degfed", None), (OBJ, None)],
+    11: [("unfed", "SM"), (OBJ, None), ("ar ddeg", None)],
+    12: [("deuddegfed", None), (OBJ, None)],
+    13: [("trydedd", "SM"), (OBJ, None), ("ar ddeg", None)],
+    14: [("pedwaredd", "SM"), (OBJ, None), ("ar ddeg", None)],
+    15: [("pymthegfed", None), (OBJ, None)],
+    16: [("unfed", None), (OBJ, None), ("ar bymtheg", None)],
+    17: [("ail", "SM"), (OBJ, None), ("ar bymtheg", None)],
+    18: [("deunawfed", None), (OBJ, None)],
+    19: [("pedwaredd", None), (OBJ, None), ("ar bymtheg", None)],
+}
+
+# The script can extrapolate the missing numbers from the base forms.
+STR_TENS = {
+    1: [("ugain", None), (OBJ, None)],
+    2: [("deugain", None), (OBJ, None)],
+    3: [("trigain", None), (OBJ, None)],
+    4: [("pedwar ugain", None), (OBJ, None)],
+}
+
+ORD_STR_TENS = {
+    1: [("ugainfed", None), (OBJ, None)],
+    2: [("deugainfed", None), (OBJ, None)],
+    3: [("trigainfed", None), (OBJ, None)],
+    4: [("pedwar ugainfed", None), (OBJ, None)],
+}
+
+STR_TENS_INFORMAL = {
+    1: ("undeg", None),
+    2: ("dauddeg", None),
+    3: ("trideg", None),
+    4: ("pedwardeg", None),
+    5: ("pumdeg", None),
+    6: ("chwedeg", None),
+    7: ("saithdeg", None),
+    8: ("wythdeg", None),
+    9: ("nawdeg", None),
+}
+
+
+GENERIC_DOLLARS = ("dolar", "dolarau")
+GENERIC_CENTS = ("ceiniog", "ceiniogau")
+
+CURRENCIES_FEM = ["GBP"]
+
+
+class Num2Word_CY(Num2Word_EUR):
+    CURRENCY_FORMS = {
+        # currency code: (sg, pl), (sg, pl)
+        # in Welsh a noun after a numeral is ALWAYS in the singular
+        "EUR": (("euro", "euros"), GENERIC_CENTS),
+        "USD": (GENERIC_DOLLARS, GENERIC_CENTS),
+        "GBP": (("punt", "punnoedd"), ("ceiniog", "ceiniogau")),
+        "CNY": (("yuan", "yuans"), ("ffen", "ffens")),
+    }
+
+    MINUS_PREFIX_WORD = "meinws "
+    FLOAT_INFIX_WORD = " pwynt "
+
+#    def setup(self):
+#        Num2Word_EU.setup(self)
+
+    def __init__(self):
+        pass
+
+    def float_to_words(self, float_number):
+        # Check if negative
+        is_negative = float_number < 0
+        abs_float = abs(float_number)
+
+        # if ordinal:
+        #     prefix = self.to_ordinal(int(abs_float))
+        # else:
+        prefix = self.to_cardinal(int(abs_float))
+        float_part = str(abs_float).split(".")[1]
+        postfix = " ".join(
+            # Drops the trailing zero and comma
+            [self.to_cardinal(int(c)) for c in float_part]
+        )
+        result = prefix + Num2Word_CY.FLOAT_INFIX_WORD + postfix
+
+        if is_negative:
+            result = "meinws " + result
+        return result
+
+    def hundred_group(
+        self, number, informal=False, gender="masc", ordinal=False
+    ):
+        hundreds = number // 100
+        until100 = number % 100  # 0 - 99
+        # list group of number words and mutation info (for the following word)
+        result = (
+            []
+        )
+        if gender == "fem":
+            CW = CARDINAL_WORDS_FEM
+        else:
+            if ordinal:
+                CW = ORDINAL_WORDS
+            else:
+                CW = CARDINAL_WORDS
+
+        if hundreds > 0:
+            if hundreds > 1:
+                result.extend((CARDINAL_WORDS[hundreds]))
+            result.extend([("cant", None), (OBJ, None)])
+            if until100:
+                if until100 in [
+                    1,
+                    8,
+                    11,
+                    16,
+                    20,
+                    21,
+                    31,
+                    36,
+                    41,
+                    48,
+                    61,
+                    68,
+                    71,
+                    81,
+                    88,
+                    91,
+                ]:
+                    result.append(("ac", None))
+                else:
+                    result.append(("a", "AM"))
+        if until100:
+            # if informal:
+            #    pass
+            if not ordinal and until100 >= 50 and until100 <= 59:
+                units = number % 10
+                if hundreds > 0:
+                    if units == 0:
+                        result.append(("hanner", None))
+                    elif units == 1:
+                        result.extend([("hanner ac un", None), (OBJ, None)])
+                    else:
+                        result.append(("hanner a", "AM"))
+                        result.extend(CW[units])
+                else:
+                    if units == 0:
+                        result.extend([("hanner cant", None), (OBJ, None)])
+                    elif units == 1:
+                        result.extend(
+                            [("hanner cant ac un", None), (OBJ, None)]
+                        )
+                    else:
+                        result.append(("hanner cant a", "AM"))
+                        result.extend(CW[units])
+            else:
+                if (number < 20 and number > 0) or (
+                    number == 0 and hundreds == 0
+                ):
+                    if gender == "fem":
+                        result.extend(CARDINAL_WORDS_FEM[int(number)])
+                    else:
+                        result.extend(CARDINAL_WORDS[int(number)])
+
+                else:
+                    tens = until100 // 20
+                    units = number % 20
+                    if ordinal and units == 0:
+                        degau = ORD_STR_TENS.get(tens)
+                    else:
+                        degau = STR_TENS.get(tens)
+
+                    if units != 0:
+                        if tens > 1:
+                            result.extend(CW[units])
+                            if degau:
+                                result.append(("a", "AM"))
+                                result.extend(degau)
+                        else:
+                            result.extend(CW[units])
+                            if degau:
+                                result.append(("ar", "SM"))
+                                result.extend(degau)
+                    elif degau:
+                        result.extend(degau)
+        return result
+
+    def to_ordinal(self, number, informal=False, gender="masc"):
+        if number < 20:
+            return makestring(ORDINAL_WORDS[number])
+        if number == 100:
+            return "canfed"
+        elif number > 100:
+            raise NotImplementedError("The given number is too large.")
+
+        return self.to_cardinal(
+            number, informal=False, gender=gender, ordinal=True
+        )
+
+    def to_cardinal(
+        self,
+        number,
+        informal=False,
+        gender="masc",
+        ordinal=False,
+        counted=None,
+        raw=False,
+    ):
+        # Handle floats first, including negative floats
+        if isinstance(number, float):
+            return self.float_to_words(number)
+
+        negative = False
+        if number < 0:
+            negative = True
+            number = -1 * number
+        if number == 0:
+            if raw:
+                return CARDINAL_WORDS[0]
+            else:
+                return makestring(CARDINAL_WORDS[0])
+        elif not number < 999 * 10**33:
+            raise NotImplementedError("The given number is too large.")
+
+        # split in groups of 10**3
+        # groups of three digits starting from right (units (1 - 999),
+        # thousands, millions, ...)
+        groups = (
+            []
+        )
+        lowestgroup = (
+            None  # find the lowest group of 3 digits > 0 for the ordinals
+        )
+        for pot in [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36]:
+            gr = (number % 10**pot) // 10 ** (pot - 3)
+            groups.append((gr, pot))
+            if gr and not lowestgroup:
+                lowestgroup = gr
+        # print("groups", groups)
+
+        result = []
+        if negative:
+            result.append(("meinws", None))
+
+        for gr, pot in reversed(groups):
+            if gr:
+                # print("AAAA", gr, pot, gender)
+                if pot == 6:
+                    g = "fem"  # mil (1000) is feminine
+                elif pot == 3:
+                    g = gender  # units depend on the following noun
+                else:
+                    g = "masc"  # millions etc are masculine
+                    # "mil" is feminine
+                if gr > 1 or pot == 3:
+                    words = self.hundred_group(
+                        gr,
+                        informal=informal,
+                        gender=g,
+                        ordinal=ordinal and (lowestgroup == gr),
+                    )
+                    result += words
+                    # print(">>>> ", words)
+                if pot > 3:
+                    result.append(MILLION_WORDS[pot - 3])
+        if raw:
+            # need to be able trigger correct mutation on currencies
+            return result
+        else:
+            if number < 100:
+                return makestring(result, counted=counted)
+            else:
+                if counted:
+                    result.extend([("o", "SM"), (counted, None)])
+                return makestring(result)
+
+    def to_currency(
+        self, val, currency="GBP", cents=True, separator=",", adjective=False
+    ):
+        # Handle integers specially - no cents
+        if isinstance(val, int):
+            minus_str = "minws " if val < 0 else ""
+            money_str = self.to_cardinal(abs(val))
+            # Simple currency name without cents
+            if abs(val) == 1:
+                currency_str = "bunt"
+            else:
+                currency_str = "bunnoedd"
+            return u'%s%s %s' % (minus_str, money_str, currency_str)
+
+        # For floats, call parent implementation
+        return super().to_currency(val, currency=currency, cents=cents,
+                                   separator=separator, adjective=adjective)
+
+    def _money_verbose(self, number, currency):
+        # used in super().to_currency(), we need to add gender
+        # here for feminine currencies
+        # if currency in CURRENCIES_FEM:  # always true in this context
+        if number > 100:
+            m = self.to_cardinal(number, gender="fem", raw=True)
+            # if currency in self.CURRENCY_FORMS:
+            c = self.CURRENCY_FORMS[currency][0][1]
+            m.append(("o", "SM"))
+            m.append((c, None))
+            # else:
+            #    c = currency
+            #    m.append((c, None))
+            return makestring(m)
+        else:
+            # if number > 1:
+            m = self.to_cardinal(number, gender="fem", raw=True)
+            # elif number == 0:
+            #    m = self.to_cardinal(number, gender="fem", raw=True)
+            # else:
+            #    m = [(OBJ, None)]
+            # if currency in self.CURRENCY_FORMS:
+            c = self.CURRENCY_FORMS[currency][0][0]
+            # else:
+            #    c = currency
+            # print("eeeeeeeee", m)
+            # m.append((c, None))
+            # print("fffffffff", m)
+            return makestring(m, counted=c)
+        # else:
+        #    return self.to_cardinal(number, raw=True)
+
+    def _cents_verbose(self, number, currency):
+        if number == 0:
+            return ""
+        # elif number > 100:
+        #     m = self.to_cardinal(number, raw=True)
+        #     # if currency in self.CURRENCY_FORMS:
+        #     c = self.CURRENCY_FORMS[currency][0][1]
+        #     m.append(("o", "SM"))
+        #     m.append((c, None))
+        #     # else:
+        #     #    c = currency
+        #     #    m.append((c, None))
+        #     return makestring(m)
+        else:
+            if number > 1:
+                m = self.to_cardinal(number, raw=True)
+            else:
+                m = [(OBJ, None)]
+            # if currency in self.CURRENCY_FORMS:
+            c = self.CURRENCY_FORMS[currency][1][0]
+            # else:
+            #    c = currency
+            return makestring(m, counted=c)
+
+
+def makestring(result, counted=None):
+    # concatenate numberwords with correct mutation
+    out = []
+    lastmut = None
+    for w, mut in result:
+        if w == OBJ:
+            if not counted:
+                continue
+            else:
+                w = counted
+                counted = None  # only first position
+        if lastmut:
+            out.append(mutate(w, lastmut))
+        else:
+            out.append(w)
+        lastmut = mut
+    return " ".join(out)
+
+
+def mutate(word, mutation):
+    # print("uuu", word, mutation)
+    if mutation == "SM":
+        return softmutation(word)
+    elif mutation == "AM":
+        return aspiratedmutation(word)
+    # return word  # does not occur
+
+
+def softmutation(word):
+    # print("SM<<<<%s>" % word)
+    if word[0] == "p" and word[1] != "h":
+        return "b" + word[1:]
+    elif word[0] == "t" and word[1] != "h":
+        return "d" + word[1:]
+    elif word[0] == "c" and word[1] != "h":
+        return "g" + word[1:]
+    elif word[0] == "b" or word[0] == "m":
+        return "f" + word[1:]
+    elif word[0] == "d" and word[1] != "d":
+        return "d" + word
+    elif word.startswith("ll"):
+        return word[1:]
+    elif word.startswith("rh"):
+        return "r" + word[2:]
+    elif word == "ugain":
+        return "hugain"
+    else:
+        return word
+
+
+def aspiratedmutation(word):
+    if word[0] == "p" and word[1] != "h":
+        return "ph" + word[1:]
+    elif word[0] == "t" and word[1] != "h":
+        return "th" + word[1:]
+    elif word[0] == "c" and word[1] != "h":
+        return "ch" + word[1:]
+    else:
+        return word