cardinal_numbers.py

#!/usr/bin/env python
# coding: utf-8

"""From https://github.com/peresolb/number-conversion/"""
import sys
import os
import nltk


# Dict for basic primitive numbers: 1-10
b = {
    1: "én",
    2: "to",
    3: "tre",
    4: "fire",
    5: "fem",
    6: "seks",
    7: "sju",
    8: "åtte",
    9: "ni",
    10: "ti",
}
b_nn = {
    1: "ein",
    2: "to",
    3: "tre",
    4: "fire",
    5: "fem",
    6: "seks",
    7: "sju",
    8: "åtte",
    9: "ni",
    10: "ti",
}

# Dict for teen primitive numbers: 11-19
t = {
    11: "elleve",
    12: "tolv",
    13: "tretten",
    14: "fjorten",
    15: "femten",
    16: "seksten",
    17: "sytten",
    18: "atten",
    19: "nitten",
}


# Dict for two digit primitive numbers: 20-90
do = {
    20: "tjue",
    30: "tretti",
    40: "førti",
    50: "femti",
    60: "seksti",
    70: "sytti",
    80: "åtti",
    90: "nitti",
}


# Dict for the 3 digit primitive number: 100
doo = {100: "hundre"}


# Dict for the 4 digit primitive number: 1000
dooo = {1000: "tusen"}


# Reverser function for primitive number dicts
def _revdict(numberdict):
    newdict = {}
    for k, v in numberdict.items():
        newdict[v] = k
    return newdict


# The reverse of the primitive number dicts, where strings are keys and integers are values,
# are name of original dict underscore 'r'
b_r, b_nn_r, t_r, do_r, doo_r, dooo_r = (
    _revdict(b),
    _revdict(b_nn),
    _revdict(t),
    _revdict(do),
    _revdict(doo),
    _revdict(dooo),
)


def _oneten(nr, reverse=False, nn=False):
    """Function taking an int from 1-10 and returning the corresponding word,
    or, if reverse=True, taking a numberword from 1-10 and returning the digit"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr <= 10:
            if nn == False:
                return b[nr]
            else:
                return b_nn[nr]
    else:
        if not type(nr) is str:
            return None
        if nn == False:
            if nr in b_r.keys():
                return b_r[nr]
        else:
            if nr in b_nn_r.keys():
                return b_nn_r[nr]


def _onedig(nr, reverse=False, nn=False):
    if reverse == False:
        if not _oneten(nr) == "ti":
            if nn == False:
                return _oneten(nr)
            else:
                return _oneten(nr, nn=True)
    if reverse == True:
        if not _oneten(nr, reverse=True) == 10:
            if nn == False:
                return _oneten(nr, reverse=True)
            else:
                return _oneten(nr, reverse=True, nn=True)


def _teen(nr, reverse=False):
    """Function taking a primitive two-digit int in the teen range and returning the
    corresponding word, or, if reverse=True, the corresponding number word"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr in t.keys():
            return t[nr]
    else:
        if not type(nr) is str:
            return None
        if nr in t_r.keys():
            return t_r[nr]


def _twodig(nr, reverse=False):
    """Function taking a primitive two-digit int in the range 20-90 and returning
    the corresponding word, or, if reverse=True, the corresponding number word"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr in do.keys():
            return do[nr]
    else:
        if not type(nr) is str:
            return None
        if nr in do_r.keys():
            return do_r[nr]


def _numparser(numword, nn=False):
    """Parse word to see if they start with a wd in firstnumwords.
    If yes, return firstnumword and second part"""
    if not type(numword) is str:
        return None
    firstpart = ""
    scndpart = ""
    firstnumwords = list(do_r.keys())
    for s in firstnumwords:
        if numword.startswith(s):
            slength = len(s)
            firstpart = s
            scndpart = numword[slength:]
            if nn == False:
                if (
                    scndpart in b_r.keys() and b_r[scndpart] < 10
                ):  # Only return if second part is dig below 10
                    return (firstpart, scndpart)
            else:
                if (
                    scndpart in b_nn_r.keys() and b_nn_r[scndpart] < 10
                ):  # Only return if second part is dig below 10
                    return (firstpart, scndpart)


def _one_to_nineteen(nr, reverse=False, nn=False):
    """Function taking a primitive two-digit int in the range 1-19
    and returning the corresponding word, or, if reverse=True, the corresponding number word"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr < 11:
            if nn == False:
                return _oneten(nr)
            else:
                return _oneten(nr, nn=True)
        elif nr < 20:
            return _teen(nr)
    else:
        if not type(nr) is str:
            return None
        if nn == False:
            if type(_oneten(nr, reverse=True)) is int:
                return _oneten(nr, reverse=True)
            elif type(_teen(nr, reverse=True)):
                return _teen(nr, reverse=True)
        else:
            if type(_oneten(nr, reverse=True, nn=True)) is int:
                return _oneten(nr, reverse=True, nn=True)
            elif type(_teen(nr, reverse=True)):
                return _teen(nr, reverse=True)


def _one_to_nn(nr, reverse=False, nn=False):
    """Function taking an int in the range 1-99 and returning the corresponding word. Reverse as before"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr > 0:
            if nr < 20:
                if nn == False:
                    return _one_to_nineteen(nr)
                else:
                    return _one_to_nineteen(nr, nn=True)
            elif nr < 100:
                if nr in do.keys():
                    return _twodig(nr)
                else:
                    nrstring = str(nr)
                    frstdig = int(nrstring[0]) * 10
                    scndig = int(nrstring[1])
                    frstwd = _twodig(frstdig)
                    if nn == False:
                        scnwd = _onedig(scndig)
                    else:
                        scnwd = _onedig(scndig, nn=True)
                    nrwd = frstwd + scnwd
                    return nrwd
    else:
        if not type(nr) is str:
            return None
        if nn == False:
            if type(_one_to_nineteen(nr, reverse=True)) is int:
                return _one_to_nineteen(nr, reverse=True)
            elif type(_twodig(nr, reverse=True)) is int:
                return _twodig(nr, reverse=True)
            else:
                if _numparser(nr) == None:
                    return None
                parsed = _numparser(nr)
                first = _twodig(parsed[0], reverse=True)
                second = _one_to_nineteen(parsed[1], reverse=True)
                return first + second
        else:
            if type(_one_to_nineteen(nr, reverse=True, nn=True)) is int:
                return _one_to_nineteen(nr, reverse=True, nn=True)
            elif type(_twodig(nr, reverse=True)) is int:
                return _twodig(nr, reverse=True)
            else:
                if _numparser(nr, nn=True) == None:
                    return None
                parsed = _numparser(nr, nn=True)
                first = _twodig(parsed[0], reverse=True)
                second = _one_to_nineteen(parsed[1], reverse=True, nn=True)
                return first + second


def _one_to_nnn(nr, reverse=False, nn=False):
    """Function taking an int in the range 1-999 and returning the corresponding word. Reverse as before"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr == 0:
            return None
        if nr < 100:  # 1-99
            if nn == False:
                return _one_to_nn(nr)
            else:
                return _one_to_nn(nr, nn=True)
        elif nr < 1000:
            if nr == 100:  # 100
                return doo[100]
            else:
                nrstring = str(nr)  # 435 181
                frstdig = int(nrstring[0])  # 4 1
                scndig = int(nrstring[1])  # 3 8
                thrdig = int(nrstring[2])  # 5 1
                scthdig = int(nrstring[1:])  # 35 81
                if nn == False:
                    frstwd = _onedig(frstdig)  # fire
                else:
                    frstwd = _onedig(frstdig, nn=True)
                nrwd = ""
                if scndig == 0:  # 405 or 400
                    if thrdig == 0:  # 400
                        nrwd = "%s %s" % (frstwd, doo[100])  # fire hundre
                    else:  # 405
                        if nn == False:
                            thrdwd = _one_to_nn(thrdig)  # fem
                        else:
                            thrdwd = _one_to_nn(thrdig, nn=True)
                        if frstdig != 1:
                            nrwd = "%s %s og %s" % (
                                frstwd,
                                doo[100],
                                thrdwd,
                            )  # fire hundre og fem
                        else:
                            nrwd = "%s og %s" % (doo[100], thrdwd)  # hundre og fem
                else:  # 435
                    scthwd = ""
                    if nn == False:
                        scthwd = _one_to_nn(scthdig)  # trettifem
                    else:
                        scthwd = _one_to_nn(scthdig, nn=True)
                    if frstdig != 1:
                        nrwd = "%s %s og %s" % (frstwd, doo[100], scthwd)
                    else:
                        nrwd = "%s og %s" % (doo[100], scthwd)  # hundre og trettifem
                return nrwd
    else:
        if not type(nr) is str:
            return None
        if type(doo_r.get(nr, None)) is int:  # hundre - 100
            return doo_r[nr]
        elif (
            len(nr.split(" ")) == 1
            and type(_one_to_nn(nr, reverse=True)) is int
            and nn == False
        ):
            return _one_to_nn(nr, reverse=True)  # 44
        elif (
            len(nr.split(" ")) == 1
            and type(_one_to_nn(nr, reverse=True, nn=True)) is int
            and nn == True
        ):
            return _one_to_nn(nr, reverse=True, nn=True)  # 44
        elif len(nr.split(" ")) == 2:  # to hundre
            splitwords = nr.split(" ")
            if nn == False and nr == "ett hundre":
                return 100
            elif nn == True and nr == "eitt hundre":
                return 100
            elif (
                type(_one_to_nn(splitwords[0], reverse=True)) is int
                and splitwords[1] == "hundre"
            ):
                return _one_to_nn(splitwords[0], reverse=True) * 100
        elif len(nr.split(" ")) == 3:  # hundre og tre
            splitwords = nr.split(" ")
            if splitwords[0] == "hundre" and splitwords[1] == "og":
                if nn == False:
                    if type(_one_to_nn(splitwords[2], reverse=True)) is int:
                        return 100 + _one_to_nn(splitwords[2], reverse=True)
                else:
                    if type(_one_to_nn(splitwords[2], reverse=True, nn=True)) is int:
                        return 100 + _one_to_nn(splitwords[2], reverse=True, nn=True)
            else:
                return None
        elif len(nr.split(" ")) == 4:  # ett hundre og trettifire, fire hundre og åtte
            splitwords = nr.split(" ")
            if nn == False:
                if (
                    splitwords[0] == "ett"
                    and splitwords[1] == "hundre"
                    and splitwords[2] == "og"
                    and type(_one_to_nn(splitwords[3], reverse=True)) is int
                ):  # ett hundre og trettifire
                    return 100 + _one_to_nn(splitwords[3], reverse=True)
                elif (
                    type(_one_to_nn(splitwords[0], reverse=True)) is int
                    and _one_to_nn(splitwords[0], reverse=True) < 10
                    and splitwords[1] == "hundre"
                    and splitwords[2] == "og"
                    and type(_one_to_nn(splitwords[3], reverse=True)) is int
                ):  # fire hundre og trettifire
                    hundreds = _one_to_nn(splitwords[0], reverse=True) * 100
                    tens = _one_to_nn(splitwords[3], reverse=True)
                    return hundreds + tens
                else:
                    return None
            else:
                if (
                    splitwords[0] == "eitt"
                    and splitwords[1] == "hundre"
                    and splitwords[2] == "og"
                    and type(_one_to_nn(splitwords[3], reverse=True, nn=True)) is int
                ):  # eit hundre og trettifire
                    return 100 + _one_to_nn(splitwords[3], reverse=True, nn=True)
                elif (
                    type(_one_to_nn(splitwords[0], reverse=True, nn=True)) is int
                    and _one_to_nn(splitwords[0], reverse=True, nn=True) < 10
                    and splitwords[1] == "hundre"
                    and splitwords[2] == "og"
                    and type(_one_to_nn(splitwords[3], reverse=True, nn=True)) is int
                ):  # fire hundre og trettifire
                    hundreds = _one_to_nn(splitwords[0], reverse=True, nn=True) * 100
                    tens = _one_to_nn(splitwords[3], reverse=True, nn=True)
                    return hundreds + tens
                else:
                    return None


def _high_hundred(nr, nn=False):
    """In Norwegian, as in English, it is possible to express the numbers 1100-1999 with hundreds,
    e.g. "tolv hundre og nittiåtte", /twelve hundred and ninety-eight/. We want to be able to convert
    these to integers. However, we don't need to produce them, so this algoritm only goes from strings to integers"""
    if not type(nr) is str:
        return None
    if len(nr.split(" ")) > 1:
        frstwd = nr.split(" ")[0]
        if not type(_teen(frstwd, reverse=True)) is int:
            return None
        frstdig = _teen(frstwd, reverse=True)
        if len(nr.split(" ")) == 2 and nr.split(" ")[1] == "hundre":  # femten hundre
            return frstdig * 100
        elif (
            len(nr.split(" ")) == 4
            and nr.split(" ")[1] == "hundre"
            and nr.split(" ")[2] == "og"
        ):
            if (
                nn == False and type(_one_to_nn(nr.split(" ")[3], reverse=True)) is int
            ):  # femten hundre og førtito
                lastdigs = _one_to_nn(nr.split(" ")[3], reverse=True)
                return (frstdig * 100) + lastdigs
            elif (
                nn == True
                and type(_one_to_nn(nr.split(" ")[3], reverse=True, nn=True)) is int
            ):  # femten hundre og førtito
                lastdigs = _one_to_nn(nr.split(" ")[3], reverse=True, nn=True)
                return (frstdig * 100) + lastdigs


def _one_to_nnnnnn(nr, reverse=False, nn=False):
    """Function taking an int in the range 1-999999 and returning the corresponding word. Reverse as before"""
    if reverse == False:
        if not type(nr) is int:
            return None
        if nr == 0:
            return None
        if nr < 1000:  # 1-999
            if nn == False:
                return _one_to_nnn(nr)
            else:
                return _one_to_nnn(nr, nn=True)
        elif nr < 1000000:  # 1000-999999
            if nr == 1000:  # 1000
                if nn == False:
                    return "ett tusen"
                else:
                    return "eitt tusen"
            else:
                nrstring = str(nr)  # Starting with last three digits. e.g. 23[456]
                ultdig = int(nrstring[-1])  # 6
                penultdig = int(nrstring[-2])  # 5
                antepenultdig = int(nrstring[-3])  # 4
                ult_and_penultdig = int(nrstring[-2:])  # 56
                ult_penult_antepenultdig = int(nrstring[-3:])  # 456
                tailstring = ""
                if antepenultdig == 0:  # 012, 002, 000
                    if penultdig == 0:  # 000, 002
                        if ultdig == 0:  # 000
                            tailstring = "tusen"
                        else:  # 002
                            if nn == False:
                                ultstring = _one_to_nnn(ultdig)
                                tailstring = "tusen og %s" % ultstring  # tusen og to
                            else:
                                ultstring = _one_to_nnn(ultdig, nn=True)
                                tailstring = "tusen og %s" % ultstring  # tusen og to
                    else:  # 012
                        if nn == False:
                            ult_and_penultstring = _one_to_nnn(ult_and_penultdig)
                            tailstring = (
                                "tusen og %s" % ult_and_penultstring
                            )  # tusen og tolv
                        else:
                            ult_and_penultstring = _one_to_nnn(
                                ult_and_penultdig, nn=True
                            )
                            tailstring = (
                                "tusen og %s" % ult_and_penultstring
                            )  # tusen og tolv
                else:  # 456
                    if nn == False:
                        ult_penult_antepenultstring = _one_to_nnn(
                            ult_penult_antepenultdig
                        )
                        if str(ult_penult_antepenultdig)[0] == "1":
                            tailstring = (
                                "tusen ett %s" % ult_penult_antepenultstring
                            )  # tusen ett hundre
                        else:
                            tailstring = (
                                "tusen %s" % ult_penult_antepenultstring
                            )  # tusen fire hundre og femtiseks
                    else:
                        ult_penult_antepenultstring = _one_to_nnn(
                            ult_penult_antepenultdig, nn=True
                        )
                        if str(ult_penult_antepenultdig)[0] == "1":
                            tailstring = (
                                "tusen eitt %s" % ult_penult_antepenultstring
                            )  # tusen ett hundre
                        else:
                            tailstring = (
                                "tusen %s" % ult_penult_antepenultstring
                            )  # tusen fire hundre og femtiseks
                startdigs = int(
                    nrstring[:-3]
                )  # startstring can consist of the 1, 2 or 3 first digits
                startstring = ""
                if startdigs == 1:  # 1001 starts with "ett"
                    if nn == False:
                        startstring = "ett"
                    else:
                        startstring = "eitt"
                elif startdigs > 99 and startdigs < 200:  # 155555 starts with ett
                    if nn == False:
                        startnumstring = _one_to_nnn(startdigs)
                        startstring = "ett %s" % startnumstring
                    else:
                        startnumstring = _one_to_nnn(startdigs, nn=True)
                        startstring = "eitt %s" % startnumstring
                else:  # the remaining numbers are purely compositional
                    if nn == False:
                        startstring = _one_to_nnn(startdigs)
                    else:
                        startstring = _one_to_nnn(startdigs, nn=True)
                numstring = "%s %s" % (startstring, tailstring)
                return numstring
    else:
        if not type(nr) is str:
            return None
        if type(_one_to_nnn(nr, reverse=True)) is int and nn == False:
            return _one_to_nnn(nr, reverse=True)  # 444
        elif type(_one_to_nnn(nr, reverse=True, nn=True)) is int and nn == True:
            return _one_to_nnn(nr, reverse=True, nn=True)  # 444
        elif nr == "tusen":  # tusen - 1000
            return 1000
        elif (
            len(nr.split(" ")) > 1 and nr.split(" ")[-1] == "tusen"
        ):  # ett tusen, ett hundre tusen etc.
            wdlist = nr.split(" ")
            firstphrase = " ".join(wdlist[:-1])
            if type(_one_to_nnn(firstphrase, reverse=True)) is int and nn == False:
                firstdig = _one_to_nnn(firstphrase, reverse=True)
                return firstdig * 1000
            elif (
                type(_one_to_nnn(firstphrase, reverse=True, nn=True)) is int
                and nn == True
            ):
                firstdig = _one_to_nnn(firstphrase, reverse=True, nn=True)
                return firstdig * 1000
            elif (
                len(nr.split(" ")) == 2 and nr.split(" ")[0] == "ett" and nn == False
            ):  # ett tusen
                return 1000
            elif len(nr.split(" ")) == 2 and nr.split(" ")[0] == "eitt" and nn == True:
                return 1000
            else:  # misspellings should not result in return value
                return None
        else:
            if len(nr.split(" ")) > 1:  # all other numbers should contain spaces
                numwordlist = nr.split(" ")
                if (
                    "tusen" in numwordlist
                ):  # Find last part of numphrase, which starts with "tusen"
                    tusenind = numwordlist.index("tusen")  # find index of "tusen"
                    lastwords = numwordlist[tusenind:]  # words from 'tusen'
                    firstwords = numwordlist[:tusenind]  # words until 'tusen'
                    lastdigs = 0
                    if len(lastwords) == 3:
                        if lastwords[1] == "og":  # 'tusen og fire' 'tusen og førtifire'
                            lastword = lastwords[-1]
                            if nn == False:
                                lastdigs = _one_to_nnn(lastword, reverse=True)
                            elif nn == True:
                                lastdigs = _one_to_nnn(lastword, reverse=True, nn=True)
                        elif (
                            nn == False
                            and type(_one_to_nnn(" ".join(lastwords[1:]), reverse=True))
                            is int
                            and lastwords[2] == "hundre"
                        ):  # tusen to hundre
                            hundredphrase = " ".join(lastwords[1:])
                            lastdigs = _one_to_nnn(hundredphrase, reverse=True)
                        elif (
                            nn == True
                            and type(
                                _one_to_nnn(
                                    " ".join(lastwords[1:]), reverse=True, nn=True
                                )
                            )
                            is int
                            and lastwords[2] == "hundre"
                        ):  # tusen to hundre
                            hundredphrase = " ".join(lastwords[1:])
                            lastdigs = _one_to_nnn(hundredphrase, reverse=True, nn=True)
                        else:  # misspellings should not result in return value
                            return None
                    elif (
                        len(lastwords) == 5 and lastwords[2] == "hundre"
                    ):  # 'tusen fire hundre og fem'
                        hundredphrase = " ".join(lastwords[1:])
                        if nn == False:
                            lastdigs = _one_to_nnn(hundredphrase, reverse=True)
                        else:
                            lastdigs = _one_to_nnn(hundredphrase, reverse=True, nn=True)
                    else:  # misspellings should not result in return value
                        return None
                    firstdigs = 0
                    firstphrase = " ".join(firstwords)
                    if len(firstwords) == 0:  # as in 'tusen og tretti'
                        firstdigs = 1000
                    elif (
                        len(firstwords) == 1 and firstwords[0] == "ett" and nn == False
                    ):
                        firstdigs = 1000
                    elif (
                        len(firstwords) == 1 and firstwords[0] == "eitt" and nn == True
                    ):
                        firstdigs = 1000
                    elif (
                        type(_one_to_nnn(firstphrase, reverse=True)) is int
                        and nn == False
                    ):
                        firstdigs = _one_to_nnn(firstphrase, reverse=True) * 1000
                    elif (
                        type(_one_to_nnn(firstphrase, reverse=True, nn=True)) is int
                        and nn == True
                    ):
                        firstdigs = (
                            _one_to_nnn(firstphrase, reverse=True, nn=True) * 1000
                        )
                    else:  # misspellings should not result in return value
                        return None
                    if type(firstdigs) is int and type(lastdigs) is int:
                        return firstdigs + lastdigs


def convert_nums(nr, reverse=False, nn=False):
    """Functions for converting numbers. Only works for numbers in range 0-999999 for now"""
    if reverse == False:
        if type(nr) is int:
            returnstring = ""
            if nr == 0:
                returnstring = "null"
            elif nr < 1000000:
                if nn == False:
                    returnstring = _one_to_nnnnnn(nr)
                else:
                    returnstring = _one_to_nnnnnn(nr, nn=True)
            else:
                return None
            return returnstring
    else:
        if type(nr) is str:
            returnint = 0
            if nr == "null":
                returnint = 0
            elif nn == False and type(_one_to_nnnnnn(nr, reverse=True)) is int:
                returnint = _one_to_nnnnnn(nr, reverse=True)
            elif nn == True and type(_one_to_nnnnnn(nr, reverse=True, nn=True)) is int:
                returnint = _one_to_nnnnnn(nr, reverse=True, nn=True)
            elif nn == False and type(_high_hundred(nr)) is int:
                returnint = _high_hundred(nr)
            elif nn == True and type(_high_hundred(nr, nn=True)) is int:
                returnint = _high_hundred(nr, nn=True)
            else:
                return None
            return returnint


if __name__ == "__main__":
    # testing
    mydigit = 243564
    mynumstring = "hundre og atten tusen fire hundre og trettién"
    mydigit_nn = 34381
    mynumstring_nn = "tre hundre og førtiein"

    print(
        "Digit conversion bm: %s\nString conversion bm: %s"
        % (convert_nums(mydigit), convert_nums(mynumstring, reverse=True))
    )
    print(
        "Digit conversion nn: %s\nString conversion nn: %s"
        % (
            convert_nums(mydigit_nn, nn=True),
            convert_nums(mynumstring_nn, nn=True, reverse=True),
        )
    )