num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_EL.py

@@ -0,0 +1,338 @@
+# -*- 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 .lang_EUR import Num2Word_EUR
+
+
+class Num2Word_EL(Num2Word_EUR):
+    CURRENCY_FORMS = {
+        'EUR': (('ευρώ', 'ευρώ'), ('λεπτό', 'λεπτά')),
+        'USD': (('δολάριο', 'δολάρια'), ('σεντ', 'σεντς')),
+        'GBP': (('λίρα', 'λίρες'), ('πέννα', 'πένες')),
+    }
+
+    def setup(self):
+        Num2Word_EUR.setup(self)
+
+        self.negword = "μείον "
+        self.pointword = "κόμμα"
+        self.errmsg_nonnum = (
+            "Μόνο αριθμοί μπορούν να μετατραπούν σε λέξεις."
+        )
+        self.errmsg_toobig = (
+            "Αριθμός πολύ μεγάλος για να μετατραπεί σε λέξεις (abs(%s) > %s)."
+        )
+        self.exclude_title = ["και", "κόμμα", "μείον"]
+
+        # Override the EU settings with Greek
+        self.GIGA_SUFFIX = ""  # Don't use the EU pattern
+        self.MEGA_SUFFIX = ""   # Don't use the EU pattern
+
+        # Mid numbers: thousands and hundreds with tens
+        self.mid_numwords = [(1000000000000, "τρισεκατομμύριο"),
+                             (1000000000, "δισεκατομμύριο"),
+                             (1000000, "εκατομμύριο"),
+                             (1000, "χίλια"), (100, "εκατό"),
+                             (90, "ενενήντα"), (80, "ογδόντα"), (70, "εβδομήντα"),
+                             (60, "εξήντα"), (50, "πενήντα"), (40, "σαράντα"),
+                             (30, "τριάντα")]
+
+        # Low numbers 0-29
+        self.low_numwords = ["είκοσι", "δεκαεννέα", "δεκαοκτώ", "δεκαεπτά",
+                             "δεκαέξι", "δεκαπέντε", "δεκατέσσερα", "δεκατρία",
+                             "δώδεκα", "έντεκα", "δέκα", "εννέα", "οκτώ",
+                             "επτά", "έξι", "πέντε", "τέσσερα", "τρία", "δύο",
+                             "ένα", "μηδέν"]
+
+        # Ordinal numbers mapping
+        self.ordinals = {
+            "ένα": "πρώτος",
+            "δύο": "δεύτερος",
+            "τρία": "τρίτος",
+            "τέσσερα": "τέταρτος",
+            "πέντε": "πέμπτος",
+            "έξι": "έκτος",
+            "επτά": "έβδομος",
+            "οκτώ": "όγδοος",
+            "εννέα": "έννατος",
+            "δέκα": "δέκατος",
+            "έντεκα": "ενδέκατος",
+            "δώδεκα": "δωδέκατος",
+            "είκοσι": "εικοστός",
+            "εκατό": "εκατοστός",
+            "χίλια": "χιλιοστός",
+            "εκατομμύριο": "εκατομμυριοστός"
+        }
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+
+        # Special handling for 1
+        if cnum == 1:
+            if nnum == 100:
+                return ("εκατό", 100)
+            elif nnum == 1000:
+                return ("χίλια", 1000)
+            elif nnum >= 1000000:
+                return ("ένα " + ntext, cnum * nnum)
+            elif nnum < 1000000:
+                return next
+
+        # Handle multiplication (larger unit)
+        if nnum > cnum:
+            if nnum == 100:
+                # Hundreds
+                if cnum == 2:
+                    return ("διακόσια", 200)
+                elif cnum == 3:
+                    return ("τριακόσια", 300)
+                elif cnum == 4:
+                    return ("τετρακόσια", 400)
+                elif cnum == 5:
+                    return ("πεντακόσια", 500)
+                elif cnum == 6:
+                    return ("εξακόσια", 600)
+                elif cnum == 7:
+                    return ("επτακόσια", 700)
+                elif cnum == 8:
+                    return ("οκτακόσια", 800)
+                elif cnum == 9:
+                    return ("εννιακόσια", 900)
+            elif nnum == 1000:
+                # Thousands - need feminine forms for certain numbers
+                if cnum == 1:
+                    # Special case: when merging compound numbers ending with 1
+                    # For feminine thousands, "ένα" becomes "μία"
+                    if "ένα" in ctext:
+                        ctext_fem = ctext.replace("ένα", "μία")
+                        return (ctext_fem + " χιλιάδες", cnum * nnum)
+                    else:
+                        return ("χίλια", 1000)
+                elif cnum == 2:
+                    return ("δύο χιλιάδες", 2000)
+                elif cnum == 3:
+                    return ("τρεις χιλιάδες", 3000)
+                elif cnum == 4:
+                    return ("τέσσερις χιλιάδες", 4000)
+                elif cnum == 200:
+                    return ("διακόσιες χιλιάδες", 200000)
+                elif cnum == 300:
+                    return ("τριακόσιες χιλιάδες", 300000)
+                elif cnum == 400:
+                    return ("τετρακόσιες χιλιάδες", 400000)
+                elif cnum == 500:
+                    return ("πεντακόσιες χιλιάδες", 500000)
+                elif cnum == 600:
+                    return ("εξακόσιες χιλιάδες", 600000)
+                elif cnum == 700:
+                    return ("επτακόσιες χιλιάδες", 700000)
+                elif cnum == 800:
+                    return ("οκτακόσιες χιλιάδες", 800000)
+                elif cnum == 900:
+                    return ("εννιακόσιες χιλιάδες", 900000)
+                else:
+                    # For other numbers, adjust the form for feminine thousands
+                    ctext_new = ctext
+                    # Convert "ένα" to "μία" for feminine thousands
+                    ctext_new = ctext_new.replace("ένα", "μία")
+                    # Convert all hundreds to feminine form for χιλιάδες
+                    ctext_new = ctext_new.replace("διακόσια", "διακόσιες")
+                    ctext_new = ctext_new.replace("τριακόσια", "τριακόσιες")
+                    ctext_new = ctext_new.replace("τετρακόσια", "τετρακόσιες")
+                    ctext_new = ctext_new.replace("πεντακόσια", "πεντακόσιες")
+                    ctext_new = ctext_new.replace("εξακόσια", "εξακόσιες")
+                    ctext_new = ctext_new.replace("επτακόσια", "επτακόσιες")
+                    ctext_new = ctext_new.replace("οκτακόσια", "οκτακόσιες")
+                    ctext_new = ctext_new.replace("εννιακόσια", "εννιακόσιες")
+                    return (ctext_new + " χιλιάδες", cnum * nnum)
+            elif nnum == 1000000:
+                # Millions - need special grammar for compound numbers
+                if cnum == 1:
+                    return ("ένα εκατομμύριο", 1000000)
+                elif cnum == 2:
+                    return ("δύο εκατομμύρια", 2000000)
+                elif cnum == 3:
+                    return ("τρία εκατομμύρια", 3000000)
+                elif cnum == 4:
+                    return ("τέσσερα εκατομμύρια", 4000000)
+                else:
+                    # For compound numbers with millions, εκατομμύρια is neuter
+                    # so we keep the neuter forms (τέσσερα, not τέσσερις)
+                    return (ctext + " εκατομμύρια", cnum * nnum)
+            elif nnum == 1000000000:
+                # Billions
+                if cnum == 1:
+                    return ("ένα δισεκατομμύριο", 1000000000)
+                else:
+                    return (ctext + " δισεκατομμύρια", cnum * nnum)
+            elif nnum == 1000000000000:
+                # Trillions
+                if cnum == 1:
+                    return ("ένα τρισεκατομμύριο", 1000000000000)
+                else:
+                    return (ctext + " τρισεκατομμύρια", cnum * nnum)
+            elif nnum >= 1000000:
+                # Other large numbers
+                if cnum == 1:
+                    return ("ένα " + ntext, cnum * nnum)
+                else:
+                    return (ctext + " " + ntext, cnum * nnum)
+            else:
+                # Regular multiplication
+                return (ctext + " " + ntext, cnum * nnum)
+
+        # Handle addition (smaller unit added)
+        else:
+            return (ctext + " " + ntext, cnum + nnum)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        word = self.to_cardinal(value)
+
+        # Handle special cases first
+        for cardinal, ordinal in self.ordinals.items():
+            if word == cardinal:
+                return ordinal
+
+        # Handle special compound numbers
+        if word == "δεκατέσσερα":
+            return "δεκατέταρτος"
+        elif word == "δεκατρία":
+            return "δεκατρίτος"
+        elif word == "ένα εκατομμύριο":
+            return "εκατομμυριοστός"
+
+        # Handle compound ordinals
+        parts = word.split()
+        if len(parts) > 1:
+            # Handle "είκοσι ένα" -> "εικοστός πρώτος"
+            if parts[0] == "είκοσι" and parts[1] == "ένα":
+                return "εικοστός πρώτος"
+            elif parts[0] == "είκοσι" and parts[1] in self.ordinals:
+                return "εικοστός " + self.ordinals[parts[1]]
+            # Handle "εκατό ένα" -> "εκατοστός πρώτος"
+            elif parts[0] == "εκατό" and parts[1] == "ένα":
+                return "εκατοστός πρώτος"
+            elif parts[0] == "εκατό" and parts[1] in self.ordinals:
+                return "εκατοστός " + self.ordinals[parts[1]]
+
+            # For compound numbers, make only the last part ordinal
+            last_part = parts[-1]
+            if last_part in self.ordinals:
+                # Transform first part if needed
+                if parts[0] == "είκοσι":
+                    parts[0] = "εικοστός"
+                elif parts[0] == "εκατό":
+                    parts[0] = "εκατοστός"
+                parts[-1] = self.ordinals[last_part]
+                return " ".join(parts)
+            # Handle other compound forms
+            elif last_part == "τέσσερα":
+                parts[-1] = "τέταρτος"
+                return " ".join(parts)
+
+        # Default ordinal formation
+        if word.endswith("α"):
+            return word[:-1] + "ος"
+        elif word.endswith("ο"):
+            return word[:-1] + "ος"
+        elif word.endswith("ι"):
+            return word + "ος"
+        else:
+            return word + "ος"
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return str(value) + "ος"
+
+    def _money_verbose(self, number, currency):
+        if currency == 'GBP' and number == 1:
+            return "μία"  # Feminine form for λίρα
+        return self.to_cardinal(number)
+
+    def _cents_verbose(self, number, currency):
+        if currency == 'GBP' and number == 1:
+            return "μία"  # Feminine form for πέννα
+        return self.to_cardinal(number)
+
+    def to_currency(self, val, currency='EUR', cents=True, separator=' και',
+                    adjective=False):
+        from decimal import Decimal
+
+        from .currency import parse_currency_parts, prefix_currency
+
+        # Check if value has fractional cents
+        decimal_val = Decimal(str(val))
+        has_fractional_cents = (decimal_val * 100) % 1 != 0
+
+        # Fix the currency parsing issue - integers should be treated as whole units
+        if isinstance(val, int):
+            left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False)
+        else:
+            left, right, is_negative = parse_currency_parts(val, is_int_with_cents=False,
+                                                            keep_precision=has_fractional_cents)
+
+        try:
+            cr1, cr2 = self.CURRENCY_FORMS[currency]
+        except KeyError:
+            raise NotImplementedError(
+                'Currency code "%s" not implemented for "%s"' %
+                (currency, self.__class__.__name__))
+
+        if adjective and currency in self.CURRENCY_ADJECTIVES:
+            cr1 = prefix_currency(self.CURRENCY_ADJECTIVES[currency], cr1)
+
+        minus_str = "%s " % self.negword.strip() if is_negative else ""
+        money_str = self._money_verbose(left, currency)
+
+        # Explicitly check if input has decimal point or non-zero cents
+        has_decimal = isinstance(val, float) or str(val).find('.') != -1
+
+        # Only include cents if:
+        # 1. Input has decimal point OR
+        # 2. Cents are non-zero
+        if has_decimal or right > 0:
+            # Handle fractional cents
+            if isinstance(right, Decimal) and has_fractional_cents:
+                # Convert fractional cents (e.g., 65.3 cents)
+                cents_str = self.to_cardinal_float(float(right)) if cents else str(float(right))
+            else:
+                cents_str = self._cents_verbose(int(right) if isinstance(right, Decimal) else right, currency) \
+                    if cents else self._cents_terse(int(right) if isinstance(right, Decimal) else right, currency)
+
+            return u'%s%s %s%s %s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1),
+                separator,
+                cents_str,
+                self.pluralize(right, cr2)
+            )
+        else:
+            return u'%s%s %s' % (
+                minus_str,
+                money_str,
+                self.pluralize(left, cr1)
+            )
+
+    def pluralize(self, n, forms):
+        if n == 1:
+            return forms[0]
+        else:
+            return forms[1]

num2words2/lang_EN.py

@@ -0,0 +1,118 @@
+# -*- 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 division, print_function, unicode_literals
+
+from . import lang_EUR
+
+
+class Num2Word_EN(lang_EUR.Num2Word_EUR):
+    def __init__(self):
+        super(Num2Word_EN, self).__init__()
+        # Override specific currency forms for proper English pluralization
+        self.CURRENCY_FORMS['EUR'] = (('euro', 'euros'), ('cent', 'cents'))
+        self.CURRENCY_FORMS['USD'] = (('dollar', 'dollars'), ('cent', 'cents'))
+        self.CURRENCY_FORMS['GBP'] = (('pound', 'pounds'), ('penny', 'pence'))
+        self.CURRENCY_FORMS['NGN'] = (('naira', 'naira'), ('kobo', 'kobo'))
+
+    def set_high_numwords(self, high):
+        max = 3 + 3 * len(high)
+        for word, n in zip(high, range(max, 3, -3)):
+            self.cards[10 ** n] = word + "illion"
+
+    def setup(self):
+        super(Num2Word_EN, self).setup()
+
+        self.negword = "minus "
+        self.pointword = "point"
+        self.exclude_title = ["and", "point", "minus"]
+
+        self.mid_numwords = [(1000, "thousand"), (100, "hundred"),
+                             (90, "ninety"), (80, "eighty"), (70, "seventy"),
+                             (60, "sixty"), (50, "fifty"), (40, "forty"),
+                             (30, "thirty")]
+        self.low_numwords = ["twenty", "nineteen", "eighteen", "seventeen",
+                             "sixteen", "fifteen", "fourteen", "thirteen",
+                             "twelve", "eleven", "ten", "nine", "eight",
+                             "seven", "six", "five", "four", "three", "two",
+                             "one", "zero"]
+        self.ords = {"one": "first",
+                     "two": "second",
+                     "three": "third",
+                     "four": "fourth",
+                     "five": "fifth",
+                     "six": "sixth",
+                     "seven": "seventh",
+                     "eight": "eighth",
+                     "nine": "ninth",
+                     "ten": "tenth",
+                     "eleven": "eleventh",
+                     "twelve": "twelfth"}
+
+    def merge(self, lpair, rpair):
+        ltext, lnum = lpair
+        rtext, rnum = rpair
+        if lnum == 1 and rnum < 100:
+            return (rtext, rnum)
+        elif 100 > lnum > rnum:
+            return ("%s-%s" % (ltext, rtext), lnum + rnum)
+        elif lnum >= 100 > rnum:
+            return ("%s and %s" % (ltext, rtext), lnum + rnum)
+        elif rnum > lnum:
+            return ("%s %s" % (ltext, rtext), lnum * rnum)
+        return ("%s, %s" % (ltext, rtext), lnum + rnum)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        outwords = self.to_cardinal(value).split(" ")
+        lastwords = outwords[-1].split("-")
+        lastword = lastwords[-1].lower()
+        try:
+            lastword = self.ords[lastword]
+        except KeyError:
+            if lastword[-1] == "y":
+                lastword = lastword[:-1] + "ie"
+            lastword += "th"
+        lastwords[-1] = self.title(lastword)
+        outwords[-1] = "-".join(lastwords)
+        return " ".join(outwords)
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        return "%s%s" % (value, self.to_ordinal(value)[-2:])
+
+    def to_year(self, val, suffix=None, longval=True):
+        if val < 0:
+            val = abs(val)
+            suffix = 'BC' if not suffix else suffix
+        high, low = (val // 100, val % 100)
+        # If year is 00XX, X00X, or beyond 9999, go cardinal.
+        if (high == 0
+                or (high % 10 == 0 and low < 10)
+                or high >= 100):
+            valtext = self.to_cardinal(val)
+        else:
+            hightext = self.to_cardinal(high)
+            if low == 0:
+                lowtext = "hundred"
+            elif low < 10:
+                lowtext = "oh-%s" % self.to_cardinal(low)
+            else:
+                lowtext = self.to_cardinal(low)
+            valtext = "%s %s" % (hightext, lowtext)
+        return (valtext if not suffix
+                else "%s %s" % (valtext, suffix))

num2words2/lang_EN_IN.py

@@ -0,0 +1,26 @@
+# -*- 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 unicode_literals
+
+from .lang_EN import Num2Word_EN
+
+
+class Num2Word_EN_IN(Num2Word_EN):
+    def set_high_numwords(self, high):
+        self.cards[10 ** 7] = "crore"
+        self.cards[10 ** 5] = "lakh"

num2words2/lang_EN_NG.py

@@ -0,0 +1,45 @@
+# -*- 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 unicode_literals
+
+from . import lang_EN
+
+
+class Num2Word_EN_NG(lang_EN.Num2Word_EN):
+
+    CURRENCY_FORMS = {
+        'NGN': (('naira', 'naira'), ('kobo', 'kobo')),
+        'EUR': (('euro', 'euros'), ('cent', 'cents')),
+        'USD': (('dollar', 'dollars'), ('cent', 'cents')),
+    }
+
+    CURRENCY_ADJECTIVES = {
+        'NGN': 'Nigerian',
+        'EUR': 'European',
+        'USD': 'US',
+    }
+
+    def to_currency(
+        self, val, currency='NGN',
+        kobo=True, separator=',',
+        adjective=False
+    ):
+        result = super(Num2Word_EN_NG, self).to_currency(
+            val, currency=currency, cents=kobo, separator=separator,
+            adjective=adjective)
+        return result

num2words2/lang_EO.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021, 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
+
+
+class Num2Word_EO(Num2Word_Base):
+    CURRENCY_FORMS = {
+        "EUR": (("eŭro", "eŭroj"), ("centimo", "centimoj")),
+        "USD": (("dolaro", "dolaroj"), ("cendo", "cendoj")),
+        "FRF": (("franko", "frankoj"), ("centimo", "centimoj")),
+        "GBP": (("pundo", "pundoj"), ("penco", "pencoj")),
+        "CNY": (("juano", "juanoj"), ("feno", "fenoj")),
+    }
+
+    GIGA_SUFFIX = "iliardo"
+    MEGA_SUFFIX = "iliono"
+
+    def set_high_numwords(self, high):
+        cap = 3 + 6 * len(high)
+
+        for word, n in zip(high, range(cap, 3, -6)):
+            if self.GIGA_SUFFIX:
+                self.cards[10 ** n] = word + self.GIGA_SUFFIX
+
+            if self.MEGA_SUFFIX:
+                self.cards[10 ** (n - 3)] = word + self.MEGA_SUFFIX
+
+    def gen_high_numwords(self, units, tens, lows):
+        out = [u + t for t in tens for u in units]
+        out.reverse()
+        return out + lows
+
+    def setup(self):
+        lows = ["naŭ", "ok", "sep", "ses", "kvin", "kvar", "tr", "b", "m"]
+        units = ["", "un", "duo", "tre", "kvatuor",
+                 "kvin", "seks", "septen", "okto", "novem"]
+        tens = ["dek", "vigint", "trigint", "kvadragint", "kvinkvagint",
+                "seksagint", "septuagint", "oktogint", "nonagint"]
+
+        self.high_numwords = ["cent"] + self.gen_high_numwords(units, tens,
+                                                               lows)
+
+        self.negword = "minus "
+        self.pointword = "komo"
+        self.errmsg_nonnum = u"Sole nombroj povas esti konvertita en vortojn."
+        self.errmsg_toobig = (
+            u"Tro granda nombro por esti konvertita en vortojn (abs(%s) > %s)."
+        )
+        self.exclude_title = ["kaj", "komo", "minus"]
+        self.mid_numwords = [(1000, "mil"), (100, "cent"), (90, "naŭdek"),
+                             (80, "okdek"), (70, "sepdek"), (60, "sesdek"),
+                             (50, "kvindek"), (40, "kvardek"), (30, "tridek")]
+        self.low_numwords = ["dudek", "dek naŭ", "dek ok", "dek sep",
+                             "dek ses", "dek kvin", "dek kvar", "dek tri",
+                             "dek du", "dek unu", "dek", "naŭ", "ok", "sep",
+                             "ses", "kvin", "kvar", "tri", "du", "unu", "nul"]
+        self.ords = {
+            "unu": "unua",
+            "du": "dua",
+            "tri": "tria",
+            "kvar": "kvara",
+            "kvin": "kvina",
+            "ses": "sesa",
+            "sep": "sepa",
+            "ok": "oka",
+            "naŭ": "naŭa",
+            "dek": "deka"
+        }
+
+    def merge(self, curr, next):
+        ctext, cnum, ntext, nnum = curr + next
+        if cnum == 1 and nnum < 1000000:
+            return next
+
+        if nnum >= 10**6 and cnum > 1:
+            return ("%s %sj" % (ctext, ntext), cnum + nnum)
+
+        if nnum == 100:
+            return ("%s%s" % (ctext, ntext), cnum + nnum)
+
+        return ("%s %s" % (ctext, ntext), cnum + nnum)
+
+    def to_ordinal(self, value):
+        self.verify_ordinal(value)
+        word = self.to_cardinal(value)
+        for src, repl in self.ords.items():
+            if word.endswith(src):
+                word = word[:-len(src)] + repl
+                return word
+
+        if word.endswith("o"):
+            word = word[:-1] + "a"
+        elif word.endswith("oj"):
+            word = word[:-2] + "a"
+        else:
+            word = word + "a"
+        return word
+
+    def to_ordinal_num(self, value):
+        self.verify_ordinal(value)
+        out = str(value)
+        out += "a"
+        return out
+
+    def to_currency(self, val, currency="EUR", cents=True, separator=" kaj",
+                    adjective=False):
+        result = super(Num2Word_EO, self).to_currency(
+            val, currency=currency, cents=cents, separator=separator,
+            adjective=adjective)
+        return result
+
+    def pluralize(self, n, forms):
+        form = 0 if n <= 1 else 1
+        return forms[form]