num2words2 0.1.0.dev1__py3-none-any.whl

num2words2/lang_ZH_HK.py

@@ -0,0 +1,48 @@
+# -*- 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 .lang_ZH import Num2Word_ZH
+
+
+class Num2Word_ZH_HK(Num2Word_ZH):
+    CURRENCY_FLOATS_CHILD = ["毫", "仙"]
+
+    CURRENCY_FORMS_CHILD = {
+        "EUR": "歐羅",
+        "JPY": "日圓",
+        "CAD": "加元",
+        "AUD": "澳元",
+        "KRW": "韓圜",
+    }
+
+    CAP_map_CHILD = [
+        ("毫", "角"),
+        ("仙", "分"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.CURRENCY_FLOATS = self.CURRENCY_FLOATS_CHILD.copy()
+        self.CURRENCY_FORMS = self.CURRENCY_FORMS.copy()
+        self.CAP_map = self.CAP_map.copy()
+
+        for k, v in self.CURRENCY_FORMS_CHILD.items():
+            self.CURRENCY_FORMS[k] = v
+        for item in self.CAP_map_CHILD:
+            self.CAP_map.append(item)

num2words2/lang_ZH_TW.py

@@ -0,0 +1,198 @@
+# -*- 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 .compat import to_s
+from .lang_ZH import Num2Word_ZH
+
+
+class Num2Word_ZH_TW(Num2Word_ZH):
+    CURRENCY_FORMS_CHILD = {
+        "XXX": (("元",), ("ㄩㄢˊ",)),  # Generic dollar
+    }
+
+    cheque_suffix = (("正",), ("ㄓㄥˋ",))
+    year = (("年",), ("ㄋㄧㄢˊ",))
+    year_prefix = (("公元", "西元"), ("ㄍㄨㄥ ㄩㄢˊ", "ㄒㄧㄩㄢˊ"))
+    year_bce = (("前",), ("ㄑㄧㄢˊ",))
+    ord_prefix = (("第",), ("ㄉㄧˋ",))
+    ROC_era = (("民國",), ("ㄇㄧㄣˊㄍㄨㄛˊ",))
+
+    def __init__(self):
+        super().__init__()
+        self.CURRENCY_FORMS = self.CURRENCY_FORMS.copy()
+
+        for k, v in self.CURRENCY_FORMS_CHILD.items():
+            self.CURRENCY_FORMS[k] = v
+
+    # Get reading for negword
+    def to_cardinal(self, value, stuff_zero=2, reading=False, prefer=None):
+        self.stuff_zero = stuff_zero
+        self.set_str_selection(reading, prefer)
+
+        try:
+            assert int(value) == value
+        except (ValueError, TypeError, AssertionError):
+            return self.to_cardinal_float(value, reading, prefer)
+
+        out = ""
+        if value < 0:
+            value = abs(value)
+            out = "%s " % self.select_text(self.negword).strip()
+
+        if value >= self.MAXVAL:
+            raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL))
+
+        val = self.splitnum(value)
+        words, num = self.clean(val)
+        out = self.title(out + words)
+
+        out = self.zh_to_cap(out, reading == "capital")
+        return out.replace(" ", "")
+
+    # Get reading for pointword
+    def to_cardinal_float(self, value, reading=False, prefer=None):
+        try:
+            float(value) == value
+        except (ValueError, TypeError, AssertionError, AttributeError):
+            raise TypeError(self.errmsg_nonnum % value)
+
+        pre, post = self.float2tuple(float(value))
+
+        post = str(post)
+        post = '0' * (self.precision - len(post)) + post
+
+        out = [self.to_cardinal(pre, reading=reading, prefer=prefer)]
+        if value < 0 and pre == 0:
+            out = [self.select_text(self.negword).strip()] + out
+
+        if self.precision:
+            out.append(self.select_text(self.title(self.pointword)))
+
+        for i in range(self.precision):
+            curr = int(post[i])
+            out.append(
+                to_s(
+                    self.to_cardinal(
+                        curr,
+                        reading=reading,
+                        prefer=prefer)))
+
+        out = self.zh_to_cap(" ".join(out), self.capital)
+        return out.replace(" ", "")
+
+    def to_ordinal(self, value, counter="", reading=False, prefer=None):
+        self.set_str_selection(reading, prefer)
+        if reading is True:
+            if counter not in self.counters and counter:
+                raise NotImplementedError(
+                    f"Reading not implemented for {counter}")
+            counter = self.counters.get(counter, "")
+        return super().to_ordinal(
+            value, counter=counter, reading=reading, prefer=prefer)
+
+    def to_ordinal_num(self, value, counter="", reading=False, prefer=None):
+        self.set_str_selection(reading, prefer)
+        if self.reading is True:
+            if counter not in self.counters and counter:
+                raise NotImplementedError(
+                    f"Reading not implemented for {counter}")
+            counter = self.counters.get(counter, "")
+        return super().to_ordinal_num(
+            value, counter=counter, reading=reading, prefer=prefer)
+
+    def to_year(self, value, era=False, reading=False, prefer=None):
+        self.set_str_selection(reading, prefer)
+        if not era:
+            return super().to_year(value, reading=reading, prefer=prefer)
+
+        if not value == int(value):
+            raise TypeError(self.errmsg_floatyear % value)
+
+        min_year = 1912
+        if value < min_year:
+            raise ValueError(
+                "Can't convert years less than %s to ROC era" %
+                min_year)
+        era_year = abs(int(value - min_year + 1))
+
+        if reading == "arabic":
+            era_year_words = era_year
+        elif era_year == 1:
+            era_year_words = self.select_text((("元",), ("ㄩㄢˊ",)))
+        elif era_year < 101:
+            era_year_words = self.to_cardinal(era_year)
+        else:
+            era_year_words = "".join(
+                [self.select_text(self.cards[int(s)]) for s in str(era_year)])
+
+        return "%s%s%s" % (self.select_text(self.ROC_era),
+                           era_year_words, self.select_text(self.year))
+
+    def setup(self):
+        super().setup()
+        self.negword = (("負",), ("ㄈㄨˋ",))
+        self.pointword = (("點",), ("ㄉㄧㄢˇ",))
+        self.exclude_title = [self.negword, self.pointword]
+
+        self.high_numwords = [
+            (("萬",), ("ㄨㄢˋ",)),                  # 10**4
+            (("億",), ("ㄧˋ",)),                    # 10**8
+            (("兆",), ("ㄓㄠˋ",)),                  # 10**12
+            (("京",), ("ㄐㄧㄥ",)),                 # 10**16
+            (("垓",), ("ㄍㄞ",)),                   # 10**20
+            (("秭",), ("ㄗˇ",)),                    # 10**24
+            (("穣",), ("ㄖㄤ",)),                   # 10**28
+            (("溝",), ("ㄍㄡ",)),                   # 10**32
+            (("澗",), ("ㄐㄧㄢˋ",)),                # 10**36
+            (("正",), ("ㄓㄥˋ",)),                  # 10**40
+            (("載",), ("ㄗㄞˇ",)),                  # 10**44
+            (("極",), ("ㄐㄧˊ",)),                  # 10**48
+            (("恆河沙",), ("ㄏㄥˊㄏㄜˊㄕㄚ",)),     # 10**52
+            (("阿僧祇",), ("ㄚㄙㄥㄑㄧˊ",)),        # 10**56
+            (("那由他",), ("ㄋㄚˋㄧㄡˊㄊㄚ",)),     # 10**60
+            (("不可思議",), ("ㄅㄨˋㄎㄜˇㄙㄧˋ",)),  # 10**64
+            (("無量",), ("ㄨˊㄌㄧㄤˋ",)),           # 10**68
+            (("不可說",), ("ㄅㄨˋㄎㄜˇㄕㄨㄛ",))    # 10**72
+        ]
+        self.high_numwords.reverse()
+
+        self.counters = {
+            "個": "˙ㄍㄜ",
+            "名": "ㄇㄧㄥˊ",
+            "位": "ㄨㄟˋ"
+        }
+
+        self.mid_numwords = [
+            (1000, (("千",), ("ㄑㄧㄢ",))),
+            (100, (("百",), ("ㄅㄞˇ",))),
+        ]
+
+        self.low_numwords = [
+            (("十", "拾"), ("ㄕˊ",)),      # 10
+            (("九", "玖"), ("ㄐㄧㄡˇ",)),  # 9
+            (("八", "捌"), ("ㄅㄚ",)),     # 8
+            (("七", "柒"), ("ㄑㄧ",)),     # 7
+            (("六", "陸"), ("ㄌㄧㄡˋ",)),  # 6
+            (("五", "伍"), ("ㄨˇ",)),      # 5
+            (("四", "肆"), ("ㄙˋ",)),      # 4
+            (("三", "參"), ("ㄙㄢ",)),     # 3
+            (("二", "貳"), ("ㄦˋ",)),      # 2
+            (("一", "壹"), ("ㄧ",)),       # 1
+            (("零", "〇"), ("ㄌㄧㄥˊ",)),     # 0
+        ]

num2words2/utils.py

@@ -0,0 +1,35 @@
+# -*- 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
+
+
+def splitbyx(n, x, format_int=True):
+    length = len(n)
+    if length > x:
+        start = length % x
+        if start > 0:
+            result = n[:start]
+            yield int(result) if format_int else result
+        for i in range(start, length, x):
+            result = n[i:i + x]
+            yield int(result) if format_int else result
+    else:
+        yield int(n) if format_int else n
+
+
+def get_digits(n):
+    a = [int(x) for x in reversed(list(('%03d' % n)[-3:]))]
+    return a

num2words2-0.1.0.dev1.data/scripts/num2words2

@@ -0,0 +1,98 @@
+#!python
+# -*- 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
+
+"""num2words2: convert numbers into words.
+
+Usage:
+    num2words2 [options] <number>
+    num2words2 --list-languages
+    num2words2 --list-converters
+    num2words2 --help
+
+Arguments:
+    <number>                Number you want to convert into words
+
+Options:
+    -L --list-languages     Show all languages.
+    -C --list-converters    Show all converters.
+    -l --lang=<lang>        Output language [default: en].
+    -t --to=<to>            Output converter [default: cardinal].
+    -h --help               Show this message.
+    -v --version            Show version.
+
+Examples:
+    $ num2words2 10001
+    ten thousand and one
+
+    $ num2words2 24,120.10
+    twenty-four thousand, one hundred and twenty point one
+
+    $ num2words2 24,120.10 -l es
+    veinticuatro mil ciento veinte punto uno
+
+    $num2words2 2.14 -l es --to currency
+    dos euros con catorce céntimos
+"""
+
+from __future__ import print_function, unicode_literals
+
+import os
+import sys
+
+from docopt import docopt
+
+import num2words2 as num2words
+
+__version__ = "0.5.16"
+__license__ = "LGPL"
+
+
+def get_languages():
+    return sorted(list(num2words.CONVERTER_CLASSES.keys()))
+
+
+def get_converters():
+    return sorted(list(num2words.CONVERTES_TYPES))
+
+
+def main():
+    version = "{}=={}".format(os.path.basename(__file__), __version__)
+    args = docopt(__doc__, argv=None, help=True, version=version, options_first=False)
+    if args["--list-languages"]:
+        for lang in get_languages():
+            sys.stdout.write(lang)
+            sys.stdout.write(os.linesep)
+        sys.exit(0)
+    if args["--list-converters"]:
+        for cvt in get_converters():
+            sys.stdout.write(cvt)
+            sys.stdout.write(os.linesep)
+        sys.exit(0)
+    try:
+        words = num2words.num2words(args['<number>'], lang=args['--lang'], to=args['--to'])
+        sys.stdout.write(words + os.linesep)
+        sys.exit(0)
+    except Exception as err:
+        sys.stderr.write(str(args['<number>']))
+        sys.stderr.write(str(err) + os.linesep)
+        sys.stderr.write(__doc__)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

num2words2-0.1.0.dev1.dist-info/METADATA

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: num2words2
+Version: 0.1.0.dev1
+Summary: Modern, actively maintained fork of num2words optimized for LLM/AI/speech applications.
+Home-page: https://github.com/jqueguiner/num2words
+Author: Jean-Louis Queguiner
+Author-email: Jean-Louis Queguiner <jean-louis.queguiner@gmail.com>
+Maintainer: Jean-Louis Queguiner
+Maintainer-email: Jean-Louis Queguiner <jean-louis.queguiner@gmail.com>
+License: LGPL-2.1
+Project-URL: Homepage, https://github.com/jqueguiner/num2words
+Project-URL: Repository, https://github.com/jqueguiner/num2words.git
+Project-URL: Bug Tracker, https://github.com/jqueguiner/num2words/issues
+Keywords: number,word,numbers,words,convert,conversion,i18n,localisation,localization,internationalisation,internationalization
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Internationalization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Localization
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: COPYING
+Requires-Dist: docopt>=0.6.2
+Dynamic: author
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+
+num2words2 library - Convert numbers to words in multiple languages
+===================================================================
+
+.. image:: https://img.shields.io/pypi/v/num2words2.svg
+   :target: https://pypi.python.org/pypi/num2words2
+
+.. image:: https://github.com/jqueguiner/num2words/workflows/CI/badge.svg
+    :target: https://github.com/jqueguiner/num2words/actions
+
+.. image:: https://coveralls.io/repos/github/jqueguiner/num2words/badge.svg?branch=master
+    :target: https://coveralls.io/github/jqueguiner/num2words?branch=master
+
+
+``num2words2`` is a modern, actively maintained fork of the original num2words library
+that converts numbers like ``42`` to words like ``forty-two``. It supports multiple
+languages (see the list below for full list of languages) and can even generate
+ordinal numbers like ``forty-second``. This fork was created to address the maintenance
+gap in the original project and optimize for modern AI/LLM/speech applications.
+
+The project is hosted on GitHub_. Contributions are welcome.
+
+.. _GitHub: https://github.com/jqueguiner/num2words
+
+Installation
+------------
+
+The easiest way to install ``num2words2`` is to use pip::
+
+    pip install num2words2
+
+Otherwise, you can download the source package and then execute::
+
+    python setup.py install
+
+The test suite in this library is new, so it's rather thin, but it can be run with::
+
+    python setup.py test
+
+To run the full CI test suite which includes linting and multiple python environments::
+
+    pip install tox
+    tox
+
+Development Setup
+-----------------
+The project uses pre-commit hooks to ensure code quality. To set up your development environment::
+
+    # Install pre-commit
+    pip install pre-commit
+
+    # Install the git hook scripts
+    pre-commit install
+
+    # Run hooks on all files (optional, useful for initial setup)
+    pre-commit run --all-files
+
+This will automatically format and lint your code before each commit using:
+
+* autopep8 - PEP 8 formatting
+* autoflake - removes unused imports and variables
+* isort - sorts imports
+* flake8 - style and quality checks
+* trailing-whitespace removal
+* end-of-file fixing
+
+Usage
+-----
+Command line::
+
+    $ num2words2 10001
+    ten thousand and one
+    $ num2words2 24,120.10
+    twenty-four thousand, one hundred and twenty point one
+    $ num2words2 24,120.10 -l es
+    veinticuatro mil ciento veinte punto uno
+    $ num2words2 2.14 -l es --to currency
+    dos euros con catorce céntimos
+
+In code there's only one function to use::
+
+    >>> from num2words2 import num2words
+    >>> num2words(42)
+    forty-two
+    >>> num2words(42, to='ordinal')
+    forty-second
+    >>> num2words(42, lang='fr')
+    quarante-deux
+
+Besides the numerical argument, there are two main optional arguments, ``to:`` and ``lang:``
+
+**to:** The converter to use. Supported values are:
+
+* ``cardinal`` (default)
+* ``ordinal``
+* ``ordinal_num``
+* ``year``
+* ``currency``
+
+**lang:** The language in which to convert the number. Supported values are:
+
+* ``en`` (English, default)
+* ``am`` (Amharic)
+* ``ar`` (Arabic)
+* ``az`` (Azerbaijani)
+* ``be`` (Belarusian)
+* ``bn`` (Bangladeshi)
+* ``ca`` (Catalan)
+* ``ce`` (Chechen)
+* ``cs`` (Czech)
+* ``cy`` (Welsh)
+* ``da`` (Danish)
+* ``de`` (German)
+* ``en_GB`` (English - Great Britain)
+* ``en_IN`` (English - India)
+* ``en_NG`` (English - Nigeria)
+* ``es`` (Spanish)
+* ``es_CO`` (Spanish - Colombia)
+* ``es_CR`` (Spanish - Costa Rica)
+* ``es_GT`` (Spanish - Guatemala)
+* ``es_VE`` (Spanish - Venezuela)
+* ``eu`` (EURO)
+* ``fa`` (Farsi)
+* ``fi`` (Finnish)
+* ``fr`` (French)
+* ``fr_BE`` (French - Belgium)
+* ``fr_CH`` (French - Switzerland)
+* ``fr_DZ`` (French - Algeria)
+* ``he`` (Hebrew)
+* ``hi`` (Hindi)
+* ``hu`` (Hungarian)
+* ``hy`` (Armenian)
+* ``id`` (Indonesian)
+* ``is`` (Icelandic)
+* ``it`` (Italian)
+* ``ja`` (Japanese)
+* ``kn`` (Kannada)
+* ``ko`` (Korean)
+* ``kz`` (Kazakh)
+* ``mn`` (Mongolian)
+* ``lt`` (Lithuanian)
+* ``lv`` (Latvian)
+* ``nl`` (Dutch)
+* ``no`` (Norwegian)
+* ``pl`` (Polish)
+* ``pt`` (Portuguese)
+* ``pt_BR`` (Portuguese - Brazilian)
+* ``ro`` (Romanian)
+* ``ru`` (Russian)
+* ``sl`` (Slovene)
+* ``sk`` (Slovak)
+* ``sr`` (Serbian)
+* ``sv`` (Swedish)
+* ``te`` (Telugu)
+* ``tet`` (Tetum)
+* ``tg`` (Tajik)
+* ``tr`` (Turkish)
+* ``th`` (Thai)
+* ``uk`` (Ukrainian)
+* ``vi`` (Vietnamese)
+* ``zh`` (Chinese - Traditional)
+* ``zh_CN`` (Chinese - Simplified / Mainland China)
+* ``zh_TW`` (Chinese - Traditional / Taiwan)
+* ``zh_HK`` (Chinese - Traditional / Hong Kong)
+
+You can supply values like ``fr_FR``; if the country doesn't exist but the
+language does, the code will fall back to the base language (i.e. ``fr``). If
+you supply an unsupported language, ``NotImplementedError`` is raised.
+Therefore, if you want to call ``num2words`` with a fallback, you can do::
+
+    try:
+        return num2words(42, lang=mylang)
+    except NotImplementedError:
+        return num2words(42, lang='en')
+
+Additionally, some converters and languages support other optional arguments
+that are needed to make the converter useful in practice.
+
+Wiki
+----
+For additional information on some localization please check the Wiki_.
+And feel free to propose wiki enhancement.
+
+.. _Wiki: https://github.com/jqueguiner/num2words/wiki
+
+History
+-------
+
+``num2words`` is based on an old library, ``pynum2word``, created by Taro Ogawa
+in 2003. Unfortunately, the library stopped being maintained and the author
+can't be reached. There was another developer, Marius Grigaitis, who in 2011
+added Lithuanian support, but didn't take over maintenance of the project.
+
+Virgil Dupras from Savoir-faire Linux based himself on Marius Grigaitis' improvements
+and re-published ``pynum2word`` as ``num2words``.
+
+``num2words2`` Fork
+-------------------
+
+``num2words2`` is a modern fork of the original ``num2words`` library, created to address
+the maintenance gap and optimize for modern AI/LLM/speech applications. This fork:
+
+* Provides active maintenance aligned with rapidly evolving AI/ML ecosystem
+* Fixes critical bugs affecting machine learning pipelines
+* Adds enhanced language support for global AI applications
+* Maintains backward compatibility with the original library
+
+Jean-Louis Queguiner