Create cardinal_numbers.py

cardinal_numbers.py

@@ -0,0 +1,690 @@
+#!/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),
+        )
+    )