pax_global_header00006660000000000000000000000064147300532120014507gustar00rootroot0000000000000052 comment=6abe2c64714a38e41de23fe20fa319d0ad2fd845 num2words-0.5.14/000077500000000000000000000000001473005321200135365ustar00rootroot00000000000000num2words-0.5.14/.coveragerc000066400000000000000000000000651473005321200156600ustar00rootroot00000000000000[run] branch = true source = num2words tests num2words-0.5.14/.github/000077500000000000000000000000001473005321200150765ustar00rootroot00000000000000num2words-0.5.14/.github/workflows/000077500000000000000000000000001473005321200171335ustar00rootroot00000000000000num2words-0.5.14/.github/workflows/ci.yml000066400000000000000000000022351473005321200202530ustar00rootroot00000000000000name: CI on: [push, pull_request] jobs: build: runs-on: ubuntu-latest strategy: matrix: python-version: [3.7, 3.8, 3.9, '3.10', '3.11', '3.12'] steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip pip install tox tox-gh-actions coveralls pip install -r requirements-test.txt - name: Test with tox run: | tox - name: Upload coverage data to coveralls.io run: coveralls --service=github env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} COVERALLS_FLAG_NAME: ${{ matrix.python-version }} COVERALLS_PARALLEL: true coveralls: name: Indicate completion to coveralls.io needs: build runs-on: ubuntu-latest container: python:3-slim steps: - name: Finished run: | pip3 install --upgrade coveralls coveralls --service=github --finish env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} num2words-0.5.14/.gitignore000066400000000000000000000000761473005321200155310ustar00rootroot00000000000000*.pyc build dist .idea/ *.egg-info /.tox .eggs/ /venv/ .venv/ num2words-0.5.14/CHANGES.rst000066400000000000000000000145431473005321200153470ustar00rootroot00000000000000Changelog ========= Version 0.5.13 -- 2023/10/18 --------------------------- * Fix a problem in Brazilian Portuguese code referred to thousands when the hundreds are exact. (#421) * Fix issue with the hundreds of millions, billions, ... when the hundreds of those are exact. (#436) * Fix negative number problem (#477) * Fix lang_DK issues (#366) * Norwegian uplift (#484) * BYN to EU and RU (#439) * Change python3.6 to python3.11 because deprecation in ubuntu 22.04 (#494) * Add support for Azerbaijani language (#495) * Add Icelandic (#380) * Hebrew long-form spelling, gender, ordinals, fractions, maxval=1e66, construct forms (#490) * Fix 15, 16, 17, 18, 19 issue (#505) * Added support for the Nigerian Naira (#507) * Fix several issues with num2words in Arabic (#512) * Guatemalan currency support (#510) * Fix #508: Handle string inputs in Italian to_ordinal (#518) * Add Slovak language support (#533) * Add gender and morphological cases support for Ukrainian (#530) * Adding genders for Russian language (#503) * Lang By Added (#506) * Add Saudi Riyal to english (#531) Version 0.5.12 -- 2022/08/19 ---------------------------- * Support Japanese Reiwa (令和/れいわ) era. (#412) * Add basic farsi support (#354) * Added Tajik language support (#406) * Fix Amharic language support (#465) * Fix Hebrew pluralize and implement to_currency (#330) * Add support to translate some currencies in italian language (#434) * Fix Polish twenties (#345) * Add uzs for ru and en (#422) * Added support for Esperanto numbers. (#387) * [ADD] to ordinal number for Turkish (#468) * Fix zeroth in Dutch to nulde fixing (#326) Version 0.5.11 -- 2022/08/03 ---------------------------- * Add KZT and UAH currencies to lang RU (#264) * Add es_NI currency (#276) * Update .gitignore to add .eggs/ directory (#280) * Fix Hebrew support (#289) * Update test_tr.py to increase coverage (#298) * Add ordinal 12,345 to ES test suite to increase coverage (#287) * Add simple tests for lang_DK.py (#286) * Add testcase for lang_EN.py (#288) * Add more tests to base.py (#283) * Fixed misspelling of 21 (cardinal and ordinal number) in IT language (#270) * Romanian issues 259 (#260) * Adding Language Support for Telugu / Bug Fix in Kannada (#263) * Add support of Kazakh language (KZ) (#306) * Update README.rst (#307) * Added support for Hungarian language (#310) * [UPD] Readme file (#363) * [ADD] num2words: add traslation to spanish of several currencies (#356) * added swedish language including test cases (#352) * Remove dupplicated line in lang_PT_BR (#355) * Fix ordinal_num output for Dutch (NL) (#369) * Polishordinals (#367) * [tr] return Turkish 0 ordinal and cardinal (#347) * Improve Ukrainian support and minor fixes in CZ, KZ, LT, LV, PL, RU, SR languages (#400) * feat: ci: replace travis by github workflows (#448) * [ES] Added missing accents ("dieciséis", "dólar", "dólares", "veintiún"), improved currency gender handling, fixed pound cent names (#443) Version 0.5.10 -- 2019/05/12 ---------------------------- * Add Kannada language localization (#243) * Revert some copyrights changed by mistake (#254) * Add indian rupee to the supported currencies (#248) * Improve currency functions for German and French (#247) * Improve Slovene localization (#246) * Improve Spanish localization (#240) * Fix typo 'seperator' on source code (#238) * Convert string to decimal values (#223) * Improve German localization and test coverage (#237) * Improve Polish localization (#233) * Fix ordinal number for French ending on 1 (#236) Version 0.5.9 -- 2019/01/10 --------------------------- * Fix encoding issue on release 0.5.8 (#229) * Improve Polish localization (#228) Version 0.5.8 -- 2018/11/17 --------------------------- * Add Portuguese (Portugal) localization (#198) * Add a command line tool to use num2words * Use language iso code for Vietnamese * Improve Korean localization (#219) * Improve Serbian (Latin) localization (#207) * Improve testing setup (#220) * Improve German localization (#214) (#222) * Improve Romanian localization (#215) * Improve Spanish localization (#187) (#200) * Improve Russian localization (#211) (#212) * Improve French localization (23902ab) * Improve Arabic localization (#176) * Improve Lithuanian and Latvian localization (#185) * Improve Ukrainian localization (#183) Version 0.5.7 -- 2018/06/27 --------------------------- * Add Finnish localization. (#170) * Add Japanese localization. (#171) * Add belgian-french localization. (#151) * Add Czech localization. (#154) * Add Thai localization. (#139) * Improve English localization. (#144) * Improve Spanish localization. (#167) * Improve Italian localization. (#143) * Improve documentation. (#155, #145, #174) Version 0.5.6 -- 2017/11/22 --------------------------- * Refactor to_currency (#135) * Allow the use of other convertes to_currency, to_year (#95) * Fix code to respect PEP8 (#98, #105) * Add Slovene localization (#97) * Add Ukrainian localization (#93) * Add Dutch localization (#91) * Add Algeria-French localization (#86) * Add Turkish localization (#85) Version 0.5.5 -- 2017/07/02 --------------------------- * Add Arabic localization (#72) * Add Spanish-Colombian and Spanish-Venezuelan localization (#67) * Add VietNam localization (#61) * Add Italian localization (#56, #59) * Improve Russian localization (#62) * Improve Polish localization (#58) Version 0.5.4 -- 2016/10/18 --------------------------- * Tons of new languages! * Add Polish localization. (#23) * Add Swiss-French localization. (#38) * Add Russian localization. (#28, #46, #48) * Add Indonesian localization. (#29) * Add Norwegian localization. (#33) * Add Danish localization. (#40) * Add Brazilian localization. (#37, #47) * Improve German localization. (#25, #27, #49) * Improve Lithuanian localization. (#52) * Improve floating point spelling. (#24) Version 0.5.3 -- 2015/06/09 --------------------------- * Fix packaging issues. (#21, #22) Version 0.5.2 -- 2015/01/23 --------------------------- * Added Latvian localization. (#9) * Improved Spanish localization. (#10, #13, #14) * Improved Lithuanian localization. (#12) Version 0.5.1 -- 2014/03/14 --------------------------- * Added Python 3 support with 2to3. (#3) * Fixed big numbers in spanish. (#2) * Fixed bugs in tanslation from 30 to 40 in spanish. (#4) * Fixed word joining in english. (#8) Version 0.5.0 -- 2013/05/28 --------------------------- * Created ``num2words`` based on the old ``pynum2word`` project. num2words-0.5.14/CODE_OF_CONDUCT.md000066400000000000000000000062311473005321200163370ustar00rootroot00000000000000# Contributor Covenant Code of Conduct ## Our Pledge In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. ## Our Standards Examples of behavior that contributes to creating a positive environment include: * Using welcoming and inclusive language * Being respectful of differing viewpoints and experiences * Gracefully accepting constructive criticism * Focusing on what is best for the community * Showing empathy towards other community members Examples of unacceptable behavior by participants include: * The use of sexualized language or imagery and unwelcome sexual attention or advances * Trolling, insulting/derogatory comments, and personal or political attacks * Public or private harassment * Publishing others' private information, such as a physical or electronic address, without explicit permission * Other conduct which could reasonably be considered inappropriate in a professional setting ## Our Responsibilities Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. ## Scope This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at support@savoirfairelinux.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version] [homepage]: http://contributor-covenant.org [version]: http://contributor-covenant.org/version/1/4/ num2words-0.5.14/CONTRIBUTING.md000066400000000000000000000033531473005321200157730ustar00rootroot00000000000000## How can I contribute ? ### Code contribution #### Issues If you are unsure where to begin contribution to Num2Words, you can start by looking through the issues page. Numerous issues are created and waiting for your love on the [issue board](https://github.com/savoirfairelinux/num2words/issues). #### Pull Requests Contributions will be accepted through the creation of Pull Requests. Here is the workflow: * Fork the repository into yours and work from there * Commit and push your changes into your fork * When you are done, create a [Pull Request](https://github.com/savoirfairelinux/num2words/compare) on the **master** branch A template is provided to create your Pull Request. Try to fill the information at the best of your knowledge. #### Pull request checklist For your pull request to be merged, the answer to the following questions must be 'yes': ##### General * Can the branch be merged automatically? ##### Testing * Do the unit tests pass? ##### Adding new code * Is the code PEP8 compliant? * Is the code covered by tests? [TravisCI](https://travis-ci.org/) is configured to run those checks on every Pull-Request. It is recommended you configure your fork to do the same. ### Reporting bugs Bugs are tracked as [GitHub issues](https://guides.github.com/features/issues/). #### How to submit a good bug report Please include as many details as possible. An issue template is automatically loaded when you create an issue. * Use a clear and comprehensive title for the issue * Describe the expected behaviour in as many details as possible * Describe the actual behaviour in as many details as possible ### Testing the application Our development process is based on Continuous Integration. We love to have a nice code coverage! num2words-0.5.14/COPYING000066400000000000000000000566731473005321200146120ustar00rootroot00000000000000GNU Lesser General Public License Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS num2words-0.5.14/ISSUE_TEMPLATE.md000066400000000000000000000001761473005321200162470ustar00rootroot00000000000000### Expected Behaviour Fill me in ... ### Actual Behaviour Fill me in ... ### Steps to reproduce * step 1 * step 2 * ... num2words-0.5.14/MANIFEST.in000066400000000000000000000001121473005321200152660ustar00rootroot00000000000000include CHANGES.rst include COPYING include tests/* include bin/num2words num2words-0.5.14/PULL_REQUEST_TEMPLATE.md000066400000000000000000000005151473005321200173400ustar00rootroot00000000000000## Fixes # by... ### Changes proposed in this pull request: * ... * ... ### Status - [ ] READY - [ ] HOLD - [X] WIP (Work-In-Progress) ### How to verify this change *Fill out this section so that a reviewer can know how to verify your change.* ### Additional notes *If applicable, explain the rationale behind your change.* num2words-0.5.14/README.rst000066400000000000000000000111331473005321200152240ustar00rootroot00000000000000num2words library - Convert numbers to words in multiple languages ================================================================== .. image:: https://img.shields.io/pypi/v/num2words.svg :target: https://pypi.python.org/pypi/num2words .. image:: https://travis-ci.org/savoirfairelinux/num2words.svg?branch=master :target: https://travis-ci.org/savoirfairelinux/num2words .. image:: https://coveralls.io/repos/github/savoirfairelinux/num2words/badge.svg?branch=master :target: https://coveralls.io/github/savoirfairelinux/num2words?branch=master ``num2words`` is a 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`` (although this last feature is a bit buggy for some languages at the moment). The project is hosted on GitHub_. Contributions are welcome. .. _GitHub: https://github.com/savoirfairelinux/num2words Installation ------------ The easiest way to install ``num2words`` is to use pip:: pip install num2words 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 Usage ----- Command line:: $ num2words 10001 ten thousand and one $ num2words 24,120.10 twenty-four thousand, one hundred and twenty point one $ num2words 24,120.10 -l es veinticuatro mil ciento veinte punto uno $num2words 2.14 -l es --to currency dos euros con catorce céntimos In code there's only one function to use:: >>> from num2words 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) * ``ce`` (Chechen) * ``cs`` (Czech) * ``cy`` (Welsh) * ``de`` (German) * ``dk`` (Danish) * ``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_VE`` (Spanish - Venezuela) * ``es_GT`` (Spanish - Guatemala) * ``eu`` (EURO) * ``fa`` (Farsi) * ``fi`` (Finnish) * ``fr`` (French) * ``fr_CH`` (French - Switzerland) * ``fr_BE`` (French - Belgium) * ``fr_DZ`` (French - Algeria) * ``he`` (Hebrew) * ``hu`` (Hungarian) * ``id`` (Indonesian) * ``is`` (Icelandic) * ``it`` (Italian) * ``ja`` (Japanese) * ``kn`` (Kannada) * ``ko`` (Korean) * ``kz`` (Kazakh) * ``lt`` (Lithuanian) * ``lv`` (Latvian) * ``no`` (Norwegian) * ``pl`` (Polish) * ``pt`` (Portuguese) * ``pt_BR`` (Portuguese - Brazilian) * ``sl`` (Slovene) * ``sr`` (Serbian) * ``sv`` (Swedish) * ``ro`` (Romanian) * ``ru`` (Russian) * ``te`` (Telugu) * ``tet`` (Tetum) * ``tg`` (Tajik) * ``tr`` (Turkish) * ``th`` (Thai) * ``vi`` (Vietnamese) * ``nl`` (Dutch) * ``uk`` (Ukrainian) 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/savoirfairelinux/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. I am thus basing myself on Marius Grigaitis' improvements and re-publishing ``pynum2word`` as ``num2words``. Virgil Dupras, Savoir-faire Linuxnum2words-0.5.14/bin/000077500000000000000000000000001473005321200143065ustar00rootroot00000000000000num2words-0.5.14/bin/num2words000077500000000000000000000056411473005321200162020ustar00rootroot00000000000000#!/usr/bin/env 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 """num2words: convert numbers into words. Usage: num2words [options] num2words --list-languages num2words --list-converters num2words --help Arguments: Number you want to convert into words Options: -L --list-languages Show all languages. -C --list-converters Show all converters. -l --lang= Output language [default: en]. -t --to= Output converter [default: cardinal]. -h --help Show this message. -v --version Show version. Examples: $ num2words 10001 ten thousand and one $ num2words 24,120.10 twenty-four thousand, one hundred and twenty point one $ num2words 24,120.10 -l es veinticuatro mil ciento veinte punto uno $num2words 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 num2words __version__ = "0.5.13" __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[''], lang=args['--lang'], to=args['--to']) sys.stdout.write(words + os.linesep) sys.exit(0) except Exception as err: sys.stderr.write(str(args[''])) sys.stderr.write(str(err) + os.linesep) sys.stderr.write(__doc__) sys.exit(1) if __name__ == '__main__': main() num2words-0.5.14/docker-compose.yml000066400000000000000000000002061473005321200171710ustar00rootroot00000000000000version: '3.0' services: web: image: python:3-alpine command: python3 -m http.server 8080 volumes: - .:/num2words num2words-0.5.14/num2words/000077500000000000000000000000001473005321200154765ustar00rootroot00000000000000num2words-0.5.14/num2words/README.md000066400000000000000000000037211473005321200167600ustar00rootroot00000000000000# Add new language for each new language you must create a file `lang_NN.py` where `NN` is the ISO 639-1 or ISO 639-3 [language code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes). This class must be a subclass of `Num2Word_EU` and implement at least the following methods ``` to_cardinal(self, number) to_ordinal(self, number) `` To integrate your language into the `num2words` module, add the name of your file to the import list in [num2words/__init__.py](num2words/__init__.py) (top of the file), and `'nn': lang_NN.Num2Word_NN()` to the `CONVERTER_CLASSES` list in the same file. Do not forget to remplace `NN` by the appropriate ISO 639 language code. The following is a template for a new language class ``` from .lang_EU import Num2Word_EU class Num2Word_CY(Num2Word_EU): def setup(self): Num2Word_EU.setup(self) def __init__(self): pass def to_ordinal(self, number): # implement here your code. number is the integer to be transformed into an ordinal # as a word (str) # which is returned return "NOT IMPLEMENTED" def to_cardinal(self, number): # implement here your code. number is the integer to be transformed into an cardinal # as a word (str) # which is returned return "NOT IMPLEMENTED" ``` You can use as manu auxiliary methods as you need to make your code efficient and readable. If you need further options like Gender, Formal/Informal, add those parameters to the methods, e.g. ``` def to_ordinal(self, number, gender="fem", informal=True) # your code pass ``` More inspiration can be found in existing `num2words/lang_NN.py` files ## Code validation In order to get your contribution merged into the main project, your code must test the validation tests. For this install the packages needed to test ``` pip install -r requirements-test.txt ``` run `tox` and `coverage` to check that the code is well formated and all parts of the code are tested ``` tox python3 -m coverage report -m ``` num2words-0.5.14/num2words/__init__.py000066400000000000000000000102561473005321200176130ustar00rootroot00000000000000# -*- 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_AM, lang_AR, lang_AZ, lang_BE, lang_BN, lang_CA, lang_CE, lang_CS, lang_CY, lang_DA, lang_DE, lang_EN, lang_EN_IN, lang_EN_NG, lang_EO, lang_ES, lang_ES_CO, lang_ES_CR, lang_ES_GT, lang_ES_NI, lang_ES_VE, lang_FA, lang_FI, lang_FR, lang_FR_BE, lang_FR_CH, lang_FR_DZ, lang_HE, lang_HU, lang_ID, lang_IS, lang_IT, lang_JA, lang_KN, lang_KO, lang_KZ, lang_LT, lang_LV, lang_NL, lang_NO, lang_PL, lang_PT, lang_PT_BR, lang_RO, lang_RU, lang_SK, lang_SL, lang_SR, lang_SV, lang_TE, lang_TET, lang_TG, lang_TH, lang_TR, lang_UK, lang_VI) CONVERTER_CLASSES = { 'am': lang_AM.Num2Word_AM(), 'ar': lang_AR.Num2Word_AR(), 'az': lang_AZ.Num2Word_AZ(), 'be': lang_BE.Num2Word_BE(), 'bn': lang_BN.Num2Word_BN(), 'ca': lang_CA.Num2Word_CA(), 'ce': lang_CE.Num2Word_CE(), 'cs': lang_CS.Num2Word_CS(), 'cy': lang_CY.Num2Word_CY(), 'en': lang_EN.Num2Word_EN(), 'en_IN': lang_EN_IN.Num2Word_EN_IN(), 'en_NG': lang_EN_NG.Num2Word_EN_NG(), 'fa': lang_FA.Num2Word_FA(), 'fr': lang_FR.Num2Word_FR(), 'fr_CH': lang_FR_CH.Num2Word_FR_CH(), 'fr_BE': lang_FR_BE.Num2Word_FR_BE(), 'fr_DZ': lang_FR_DZ.Num2Word_FR_DZ(), 'de': lang_DE.Num2Word_DE(), 'fi': lang_FI.Num2Word_FI(), 'eo': lang_EO.Num2Word_EO(), 'es': lang_ES.Num2Word_ES(), 'es_CO': lang_ES_CO.Num2Word_ES_CO(), 'es_CR': lang_ES_CR.Num2Word_ES_CR(), 'es_GT': lang_ES_GT.Num2Word_ES_GT(), 'es_NI': lang_ES_NI.Num2Word_ES_NI(), 'es_VE': lang_ES_VE.Num2Word_ES_VE(), 'id': lang_ID.Num2Word_ID(), 'ja': lang_JA.Num2Word_JA(), 'kn': lang_KN.Num2Word_KN(), 'ko': lang_KO.Num2Word_KO(), 'kz': lang_KZ.Num2Word_KZ(), 'lt': lang_LT.Num2Word_LT(), 'lv': lang_LV.Num2Word_LV(), 'pl': lang_PL.Num2Word_PL(), 'ro': lang_RO.Num2Word_RO(), 'ru': lang_RU.Num2Word_RU(), 'sk': lang_SK.Num2Word_SK(), 'sl': lang_SL.Num2Word_SL(), 'sr': lang_SR.Num2Word_SR(), 'sv': lang_SV.Num2Word_SV(), 'no': lang_NO.Num2Word_NO(), 'da': lang_DA.Num2Word_DA(), 'pt': lang_PT.Num2Word_PT(), 'pt_BR': lang_PT_BR.Num2Word_PT_BR(), 'he': lang_HE.Num2Word_HE(), 'it': lang_IT.Num2Word_IT(), 'vi': lang_VI.Num2Word_VI(), 'tg': lang_TG.Num2Word_TG(), 'th': lang_TH.Num2Word_TH(), 'tr': lang_TR.Num2Word_TR(), 'nl': lang_NL.Num2Word_NL(), 'uk': lang_UK.Num2Word_UK(), 'te': lang_TE.Num2Word_TE(), 'tet': lang_TET.Num2Word_TET(), 'hu': lang_HU.Num2Word_HU(), 'is': lang_IS.Num2Word_IS(), } CONVERTES_TYPES = ['cardinal', 'ordinal', 'ordinal_num', 'year', 'currency'] def num2words(number, ordinal=False, lang='en', to='cardinal', **kwargs): # We try the full language first if lang not in CONVERTER_CLASSES: # ... and then try only the first 2 letters lang = lang[:2] if lang not in CONVERTER_CLASSES: raise NotImplementedError() converter = CONVERTER_CLASSES[lang] if isinstance(number, str): number = converter.str_to_number(number) # backwards compatible if ordinal: to = 'ordinal' if to not in CONVERTES_TYPES: raise NotImplementedError() return getattr(converter, 'to_{}'.format(to))(number, **kwargs) num2words-0.5.14/num2words/base.py000066400000000000000000000234461473005321200167730ustar00rootroot00000000000000# -*- 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 import math from collections import OrderedDict from decimal import Decimal from .compat import to_s from .currency import parse_currency_parts, prefix_currency class Num2Word_Base(object): CURRENCY_FORMS = {} CURRENCY_ADJECTIVES = {} def __init__(self): self.is_title = False self.precision = 2 self.exclude_title = [] self.negword = "(-) " self.pointword = "(.)" self.errmsg_nonnum = "type(%s) not in [long, int, float]" self.errmsg_floatord = "Cannot treat float %s as ordinal." self.errmsg_negord = "Cannot treat negative num %s as ordinal." self.errmsg_toobig = "abs(%s) must be less than %s." self.setup() # uses cards if any(hasattr(self, field) for field in ['high_numwords', 'mid_numwords', 'low_numwords']): self.cards = OrderedDict() self.set_numwords() self.MAXVAL = 1000 * list(self.cards.keys())[0] def set_numwords(self): self.set_high_numwords(self.high_numwords) self.set_mid_numwords(self.mid_numwords) self.set_low_numwords(self.low_numwords) def set_high_numwords(self, *args): raise NotImplementedError def set_mid_numwords(self, mid): for key, val in mid: self.cards[key] = val def set_low_numwords(self, numwords): for word, n in zip(numwords, range(len(numwords) - 1, -1, -1)): self.cards[n] = word def splitnum(self, value): for elem in self.cards: if elem > value: continue out = [] if value == 0: div, mod = 1, 0 else: div, mod = divmod(value, elem) if div == 1: out.append((self.cards[1], 1)) else: if div == value: # The system tallies, eg Roman Numerals return [(div * self.cards[elem], div*elem)] out.append(self.splitnum(div)) out.append((self.cards[elem], elem)) if mod: out.append(self.splitnum(mod)) return out def parse_minus(self, num_str): """Detach minus and return it as symbol with new num_str.""" if num_str.startswith('-'): # Extra spacing to compensate if there is no minus. return '%s ' % self.negword.strip(), num_str[1:] return '', num_str def str_to_number(self, value): return Decimal(value) def to_cardinal(self, value): try: assert int(value) == value except (ValueError, TypeError, AssertionError): return self.to_cardinal_float(value) out = "" if value < 0: value = abs(value) out = "%s " % self.negword.strip() if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) val = self.splitnum(value) words, num = self.clean(val) return self.title(out + words) def float2tuple(self, value): pre = int(value) # Simple way of finding decimal places to update the precision self.precision = abs(Decimal(str(value)).as_tuple().exponent) post = abs(value - pre) * 10**self.precision if abs(round(post) - post) < 0.01: # We generally floor all values beyond our precision (rather than # rounding), but in cases where we have something like 1.239999999, # which is probably due to python's handling of floats, we actually # want to consider it as 1.24 instead of 1.23 post = int(round(post)) else: post = int(math.floor(post)) return pre, post def to_cardinal_float(self, value): 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)] if self.precision: out.append(self.title(self.pointword)) for i in range(self.precision): curr = int(post[i]) out.append(to_s(self.to_cardinal(curr))) return " ".join(out) def merge(self, curr, next): raise NotImplementedError def clean(self, val): out = val while len(val) != 1: out = [] left, right = val[:2] if isinstance(left, tuple) and isinstance(right, tuple): out.append(self.merge(left, right)) if val[2:]: out.append(val[2:]) else: for elem in val: if isinstance(elem, list): if len(elem) == 1: out.append(elem[0]) else: out.append(self.clean(elem)) else: out.append(elem) val = out return out[0] def title(self, value): if self.is_title: out = [] value = value.split() for word in value: if word in self.exclude_title: out.append(word) else: out.append(word[0].upper() + word[1:]) value = " ".join(out) return value def verify_ordinal(self, value): if not value == int(value): raise TypeError(self.errmsg_floatord % value) if not abs(value) == value: raise TypeError(self.errmsg_negord % value) def to_ordinal(self, value): return self.to_cardinal(value) def to_ordinal_num(self, value): return value # Trivial version def inflect(self, value, text): text = text.split("/") if value == 1: return text[0] return "".join(text) # //CHECK: generalise? Any others like pounds/shillings/pence? def to_splitnum(self, val, hightxt="", lowtxt="", jointxt="", divisor=100, longval=True, cents=True): out = [] if isinstance(val, float): high, low = self.float2tuple(val) else: try: high, low = val except TypeError: high, low = divmod(val, divisor) if high: hightxt = self.title(self.inflect(high, hightxt)) out.append(self.to_cardinal(high)) if low: if longval: if hightxt: out.append(hightxt) if jointxt: out.append(self.title(jointxt)) elif hightxt: out.append(hightxt) if low: if cents: out.append(self.to_cardinal(low)) else: out.append("%02d" % low) if lowtxt and longval: out.append(self.title(self.inflect(low, lowtxt))) return " ".join(out) def to_year(self, value, **kwargs): return self.to_cardinal(value) def pluralize(self, n, forms): """ Should resolve gettext form: http://docs.translatehouse.org/projects/localization-guide/en/latest/l10n/pluralforms.html """ raise NotImplementedError def _money_verbose(self, number, currency): return self.to_cardinal(number) def _cents_verbose(self, number, currency): return self.to_cardinal(number) def _cents_terse(self, number, currency): return "%02d" % number def to_currency(self, val, currency='EUR', cents=True, separator=',', adjective=False): """ Args: val: Numeric value currency (str): Currency code cents (bool): Verbose cents separator (str): Cent separator adjective (bool): Prefix currency name with adjective Returns: str: Formatted string """ left, right, is_negative = parse_currency_parts(val) 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) cents_str = self._cents_verbose(right, currency) \ if cents else self._cents_terse(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) ) def setup(self): pass num2words-0.5.14/num2words/compat.py000066400000000000000000000020201473005321200173250ustar00rootroot00000000000000# -*- 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 try: strtype = basestring except NameError: strtype = str def to_s(val): try: return unicode(val) except NameError: return str(val) num2words-0.5.14/num2words/currency.py000066400000000000000000000033411473005321200177030ustar00rootroot00000000000000# -*- 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 from decimal import ROUND_HALF_UP, Decimal def parse_currency_parts(value, is_int_with_cents=True): if isinstance(value, int): if is_int_with_cents: # assume cents if value is integer negative = value < 0 value = abs(value) integer, cents = divmod(value, 100) else: negative = value < 0 integer, cents = abs(value), 0 else: value = Decimal(value) value = value.quantize( Decimal('.01'), rounding=ROUND_HALF_UP ) negative = value < 0 value = abs(value) integer, fraction = divmod(value, 1) integer = int(integer) cents = int(fraction * 100) return integer, cents, negative def prefix_currency(prefix, base): return tuple("%s %s" % (prefix, i) for i in base) num2words-0.5.14/num2words/lang_AM.py000066400000000000000000000127561473005321200173610ustar00rootroot00000000000000# -*- 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_EU class Num2Word_AM(lang_EU.Num2Word_EU): CURRENCY_FORMS = {'ETB': (('ብር', 'ብር'), ('ሳንቲም', 'ሳንቲም'))} GIGA_SUFFIX = 'ቢሊዮን' MEGA_SUFFIX = 'ሚሊዮን' def set_high_numwords(self, high): cap = 3 * (len(high) + 1) for word, n in zip(high, range(cap, 5, -3)): if n == 9: self.cards[10 ** n] = word + self.GIGA_SUFFIX else: self.cards[10 ** n] = word + self.MEGA_SUFFIX def setup(self): super(Num2Word_AM, self).setup() self.negword = 'አሉታዊ ' self.pointword = 'ነጥብ' self.exclude_title = ['እና', 'ነጥብ', 'አሉታዊ'] self.mid_numwords = [(1000, 'ሺህ'), (100, 'መቶ'), (90, 'ዘጠና'), (80, 'ሰማኒያ'), (70, 'ሰባ'), (60, 'ስድሳ'), (50, 'አምሳ'), (40, 'አርባ'), (30, 'ሠላሳ')] self.low_numwords = ['ሃያ', 'አሥራ ዘጠኝ', 'አሥራ ስምንት', 'አሥራ ሰባት', 'አስራ ስድስት', 'አሥራ አምስት', 'አሥራ አራት', 'አሥራ ሦስት', 'አሥራ ሁለት', 'አሥራ አንድ', 'አሥር', 'ዘጠኝ', 'ስምንት', 'ሰባት', 'ስድስት', 'አምስት', 'አራት', 'ሦስት', 'ሁለት', 'አንድ', 'ዜሮ'] self.ords = {'አንድ': 'አንደኛ', 'ሁለት': 'ሁለተኛ', 'ሦስት': 'ሦስተኛ', 'አራት': 'አራተኛ', 'አምስት': 'አምስተኛ', 'ስድስት': 'ስድስተኛ', 'ሰባት': 'ሰባተኛ', 'ስምንት': 'ስምንተኛ', 'ዘጠኝ': 'ዘጠነኛ', 'አሥር': 'አሥረኛ', 'አሥራ አንድ': 'አሥራ አንደኛ', 'አሥራ ሁለት': 'አሥራ ሁለተኛ', 'አሥራ ሦስት': 'አሥራ ሦስተኛ', 'አሥራ አራት': 'አሥራ አራተኛ', 'አሥራ አምስት': 'አሥራ አምስተኛ', 'አሥራ ስድስት': 'አሥራ ስድስተኛ', 'አሥራ ሰባት': 'አሥራ ሰባተኛ', 'አሥራ ስምንት': 'አሥራ ስምንተኛ', 'አሥራ ዘጠኝ': 'አሥራ ዘጠነኛ'} def to_cardinal(self, value): try: assert int(value) == value except (ValueError, TypeError, AssertionError): return self.to_cardinal_float(value) out = '' if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) if value == 100: return self.title(out + 'መቶ') else: val = self.splitnum(value) words, num = self.clean(val) return self.title(out + words) 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 %s' % (ltext, rtext), lnum + rnum elif rnum > lnum: 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: lastword += 'ኛ' 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)[-1:]) def to_currency(self, val, currency='ብር', cents=True, separator=' ከ', adjective=True): result = super(Num2Word_AM, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) return result def to_year(self, val, longval=True): if not (val // 100) % 10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt='መቶ', longval=longval) num2words-0.5.14/num2words/lang_AR.py000066400000000000000000000440041473005321200173550ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2018, Abdullah Alhazmy, Alhazmy13. 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 import decimal import math import re from decimal import Decimal from math import floor from .base import Num2Word_Base CURRENCY_SR = [("ريال", "ريالان", "ريالات", "ريالاً"), ("هللة", "هللتان", "هللات", "هللة")] CURRENCY_EGP = [("جنيه", "جنيهان", "جنيهات", "جنيهاً"), ("قرش", "قرشان", "قروش", "قرش")] CURRENCY_KWD = [("دينار", "ديناران", "دينارات", "ديناراً"), ("فلس", "فلسان", "فلس", "فلس")] CURRENCY_TND = [("دينار", "ديناران", "دينارات", "ديناراً"), ("مليماً", "ميلمان", "مليمات", "مليم")] ARABIC_ONES = [ "", "واحد", "اثنان", "ثلاثة", "أربعة", "خمسة", "ستة", "سبعة", "ثمانية", "تسعة", "عشرة", "أحد عشر", "اثنا عشر", "ثلاثة عشر", "أربعة عشر", "خمسة عشر", "ستة عشر", "سبعة عشر", "ثمانية عشر", "تسعة عشر" ] class Num2Word_AR(Num2Word_Base): errmsg_toobig = "abs(%s) must be less than %s." MAXVAL = 10**51 def __init__(self): super().__init__() self.number = 0 self.arabicPrefixText = "" self.arabicSuffixText = "" self.integer_value = 0 self._decimalValue = "" self.partPrecision = 2 self.currency_unit = CURRENCY_SR[0] self.currency_subunit = CURRENCY_SR[1] self.isCurrencyPartNameFeminine = True self.isCurrencyNameFeminine = False self.separator = 'و' self.arabicOnes = ARABIC_ONES self.arabicFeminineOnes = [ "", "إحدى", "اثنتان", "ثلاث", "أربع", "خمس", "ست", "سبع", "ثمان", "تسع", "عشر", "إحدى عشرة", "اثنتا عشرة", "ثلاث عشرة", "أربع عشرة", "خمس عشرة", "ست عشرة", "سبع عشرة", "ثماني عشرة", "تسع عشرة" ] self.arabicOrdinal = [ "", "اول", "ثاني", "ثالث", "رابع", "خامس", "سادس", "سابع", "ثامن", "تاسع", "عاشر", "حادي عشر", "ثاني عشر", "ثالث عشر", "رابع عشر", "خامس عشر", "سادس عشر", "سابع عشر", "ثامن عشر", "تاسع عشر" ] self.arabicTens = [ "عشرون", "ثلاثون", "أربعون", "خمسون", "ستون", "سبعون", "ثمانون", "تسعون" ] self.arabicHundreds = [ "", "مائة", "مئتان", "ثلاثمائة", "أربعمائة", "خمسمائة", "ستمائة", "سبعمائة", "ثمانمائة", "تسعمائة" ] self.arabicAppendedTwos = [ "مئتا", "ألفا", "مليونا", "مليارا", "تريليونا", "كوادريليونا", "كوينتليونا", "سكستيليونا", "سبتيليونا", "أوكتيليونا ", "نونيليونا", "ديسيليونا", "أندسيليونا", "دوديسيليونا", "تريديسيليونا", "كوادريسيليونا", "كوينتينيليونا" ] self.arabicTwos = [ "مئتان", "ألفان", "مليونان", "ملياران", "تريليونان", "كوادريليونان", "كوينتليونان", "سكستيليونان", "سبتيليونان", "أوكتيليونان ", "نونيليونان ", "ديسيليونان", "أندسيليونان", "دوديسيليونان", "تريديسيليونان", "كوادريسيليونان", "كوينتينيليونان" ] self.arabicGroup = [ "مائة", "ألف", "مليون", "مليار", "تريليون", "كوادريليون", "كوينتليون", "سكستيليون", "سبتيليون", "أوكتيليون", "نونيليون", "ديسيليون", "أندسيليون", "دوديسيليون", "تريديسيليون", "كوادريسيليون", "كوينتينيليون" ] self.arabicAppendedGroup = [ "", "ألفاً", "مليوناً", "ملياراً", "تريليوناً", "كوادريليوناً", "كوينتليوناً", "سكستيليوناً", "سبتيليوناً", "أوكتيليوناً", "نونيليوناً", "ديسيليوناً", "أندسيليوناً", "دوديسيليوناً", "تريديسيليوناً", "كوادريسيليوناً", "كوينتينيليوناً" ] self.arabicPluralGroups = [ "", "آلاف", "ملايين", "مليارات", "تريليونات", "كوادريليونات", "كوينتليونات", "سكستيليونات", "سبتيليونات", "أوكتيليونات", "نونيليونات", "ديسيليونات", "أندسيليونات", "دوديسيليونات", "تريديسيليونات", "كوادريسيليونات", "كوينتينيليونات" ] assert len(self.arabicAppendedGroup) == len(self.arabicGroup) assert len(self.arabicPluralGroups) == len(self.arabicGroup) assert len(self.arabicAppendedTwos) == len(self.arabicTwos) def number_to_arabic(self, arabic_prefix_text, arabic_suffix_text): self.arabicPrefixText = arabic_prefix_text self.arabicSuffixText = arabic_suffix_text self.extract_integer_and_decimal_parts() def extract_integer_and_decimal_parts(self): splits = re.split('\\.', str(self.number)) self.integer_value = int(splits[0]) if len(splits) > 1: self._decimalValue = int(self.decimal_value(splits[1])) else: self._decimalValue = 0 def decimal_value(self, decimal_part): if self.partPrecision is not len(decimal_part): decimal_part_length = len(decimal_part) decimal_part_builder = decimal_part for i in range(0, self.partPrecision - decimal_part_length): decimal_part_builder += '0' decimal_part = decimal_part_builder if len(decimal_part) <= self.partPrecision: dec = len(decimal_part) else: dec = self.partPrecision result = decimal_part[0: dec] else: result = decimal_part # The following is useless (never happens) # for i in range(len(result), self.partPrecision): # result += '0' return result def digit_feminine_status(self, digit, group_level): if group_level == -1: if self.isCurrencyPartNameFeminine: return self.arabicFeminineOnes[int(digit)] else: # Note: this never happens return self.arabicOnes[int(digit)] elif group_level == 0: if self.isCurrencyNameFeminine: return self.arabicFeminineOnes[int(digit)] else: return self.arabicOnes[int(digit)] else: return self.arabicOnes[int(digit)] def process_arabic_group(self, group_number, group_level, remaining_number): tens = Decimal(group_number) % Decimal(100) hundreds = Decimal(group_number) / Decimal(100) ret_val = "" if int(hundreds) > 0: if tens == 0 and int(hundreds) == 2: ret_val = "{}".format(self.arabicAppendedTwos[0]) else: ret_val = "{}".format(self.arabicHundreds[int(hundreds)]) if ret_val != "" and tens != 0: ret_val += " و " if tens > 0: if tens < 20: # if int(group_level) >= len(self.arabicTwos): # raise OverflowError(self.errmsg_toobig % # (self.number, self.MAXVAL)) assert int(group_level) < len(self.arabicTwos) if tens == 2 and int(hundreds) == 0 and group_level > 0: pow = int(math.log10(self.integer_value)) if self.integer_value > 10 and pow % 3 == 0 and \ self.integer_value == 2 * (10 ** pow): ret_val = "{}".format( self.arabicAppendedTwos[int(group_level)]) else: ret_val = "{}".format( self.arabicTwos[int(group_level)]) else: if tens == 1 and group_level > 0 and hundreds == 0: # Note: this never happens # (hundreds == 0 only if group_number is 0) ret_val += "" elif (tens == 1 or tens == 2) and ( group_level == 0 or group_level == -1) and \ hundreds == 0 and remaining_number == 0: # Note: this never happens (idem) ret_val += "" elif tens == 1 and group_level > 0: ret_val += self.arabicGroup[int(group_level)] else: ret_val += self.digit_feminine_status(int(tens), group_level) else: ones = tens % 10 tens = (tens / 10) - 2 if ones > 0: ret_val += self.digit_feminine_status(ones, group_level) if ret_val != "" and ones != 0: ret_val += " و " ret_val += self.arabicTens[int(tens)] return ret_val # We use this instead of built-in `abs` function, # because `abs` suffers from loss of precision for big numbers def abs(self, number): return number if number >= 0 else -number # We use this instead of `"{:09d}".format(number)`, # because the string conversion suffers from loss of # precision for big numbers def to_str(self, number): integer = int(number) if integer == number: return str(integer) decimal = round((number - integer) * 10**9) return str(integer) + "." + "{:09d}".format(decimal).rstrip("0") def convert(self, value): self.number = self.to_str(value) self.number_to_arabic(self.arabicPrefixText, self.arabicSuffixText) return self.convert_to_arabic() def convert_to_arabic(self): temp_number = Decimal(self.number) if temp_number == Decimal(0): return "صفر" decimal_string = self.process_arabic_group(self._decimalValue, -1, Decimal(0)) ret_val = "" group = 0 while temp_number > Decimal(0): temp_number_dec = Decimal(str(temp_number)) try: number_to_process = int(temp_number_dec % Decimal(str(1000))) except decimal.InvalidOperation: decimal.getcontext().prec = len( temp_number_dec.as_tuple().digits ) number_to_process = int(temp_number_dec % Decimal(str(1000))) temp_number = int(temp_number_dec / Decimal(1000)) group_description = \ self.process_arabic_group(number_to_process, group, Decimal(floor(temp_number))) if group_description != '': if group > 0: if ret_val != "": ret_val = "{}و {}".format("", ret_val) if number_to_process != 2 and number_to_process != 1: # if group >= len(self.arabicGroup): # raise OverflowError(self.errmsg_toobig % # (self.number, self.MAXVAL) # ) assert group < len(self.arabicGroup) if number_to_process % 100 != 1: if 3 <= number_to_process <= 10: ret_val = "{} {}".format( self.arabicPluralGroups[group], ret_val) else: if ret_val != "": ret_val = "{} {}".format( self.arabicAppendedGroup[group], ret_val) else: ret_val = "{} {}".format( self.arabicGroup[group], ret_val) else: ret_val = "{} {}".format(self.arabicGroup[group], ret_val) ret_val = "{} {}".format(group_description, ret_val) group += 1 formatted_number = "" if self.arabicPrefixText != "": formatted_number += "{} ".format(self.arabicPrefixText) formatted_number += ret_val if self.integer_value != 0: remaining100 = int(self.integer_value % 100) if remaining100 == 0: formatted_number += self.currency_unit[0] elif remaining100 == 1: formatted_number += self.currency_unit[0] elif remaining100 == 2: if self.integer_value == 2: formatted_number += self.currency_unit[1] else: formatted_number += self.currency_unit[0] elif 3 <= remaining100 <= 10: formatted_number += self.currency_unit[2] elif 11 <= remaining100 <= 99: formatted_number += self.currency_unit[3] if self._decimalValue != 0: formatted_number += " {} ".format(self.separator) formatted_number += decimal_string if self._decimalValue != 0: formatted_number += " " remaining100 = int(self._decimalValue % 100) if remaining100 == 0: formatted_number += self.currency_subunit[0] elif remaining100 == 1: formatted_number += self.currency_subunit[0] elif remaining100 == 2: formatted_number += self.currency_subunit[1] elif 3 <= remaining100 <= 10: formatted_number += self.currency_subunit[2] elif 11 <= remaining100 <= 99: formatted_number += self.currency_subunit[3] if self.arabicSuffixText != "": formatted_number += " {}".format(self.arabicSuffixText) return formatted_number def validate_number(self, number): if number >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (number, self.MAXVAL)) return number def set_currency_prefer(self, currency): if currency == 'TND': self.currency_unit = CURRENCY_TND[0] self.currency_subunit = CURRENCY_TND[1] self.partPrecision = 3 elif currency == 'EGP': self.currency_unit = CURRENCY_EGP[0] self.currency_subunit = CURRENCY_EGP[1] self.partPrecision = 2 elif currency == 'KWD': self.currency_unit = CURRENCY_KWD[0] self.currency_subunit = CURRENCY_KWD[1] self.partPrecision = 2 else: self.currency_unit = CURRENCY_SR[0] self.currency_subunit = CURRENCY_SR[1] self.partPrecision = 2 def to_currency(self, value, currency='SR', prefix='', suffix=''): self.set_currency_prefer(currency) self.isCurrencyNameFeminine = False self.separator = "و" self.arabicOnes = ARABIC_ONES self.arabicPrefixText = prefix self.arabicSuffixText = suffix return self.convert(value=value) def to_ordinal(self, number, prefix=''): if number <= 19: return "{}".format(self.arabicOrdinal[number]) if number < 100: self.isCurrencyNameFeminine = True else: self.isCurrencyNameFeminine = False self.currency_subunit = ('', '', '', '') self.currency_unit = ('', '', '', '') self.arabicPrefixText = prefix self.arabicSuffixText = "" return "{}".format(self.convert(self.abs(number)).strip()) def to_year(self, value): value = self.validate_number(value) return self.to_cardinal(value) def to_ordinal_num(self, value): return self.to_ordinal(value).strip() def to_cardinal(self, number): self.isCurrencyNameFeminine = False number = self.validate_number(number) minus = '' if number < 0: minus = 'سالب ' self.separator = ',' self.currency_subunit = ('', '', '', '') self.currency_unit = ('', '', '', '') self.arabicPrefixText = "" self.arabicSuffixText = "" self.arabicOnes = ARABIC_ONES return minus + self.convert(value=self.abs(number)).strip() num2words-0.5.14/num2words/lang_AZ.py000066400000000000000000000142531473005321200173700ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base class Num2Word_AZ(Num2Word_Base): DIGITS = { 0: u"sıfır", 1: u"bir", 2: u"iki", 3: u"üç", 4: u"dörd", 5: u"beş", 6: u"altı", 7: u"yeddi", 8: u"səkkiz", 9: u"doqquz", } DECIMALS = { 1: u"on", 2: u"iyirmi", 3: u"otuz", 4: u"qırx", 5: u"əlli", 6: u"altmış", 7: u"yetmiş", 8: u"səksən", 9: u"doxsan", } POWERS_OF_TEN = { 2: u"yüz", 3: u"min", 6: u"milyon", 9: u"milyard", 12: u"trilyon", 15: u"katrilyon", 18: u"kentilyon", 21: u"sekstilyon", 24: u"septilyon", 27: u"oktilyon", 30: u"nonilyon", 33: u"desilyon", 36: u"undesilyon", 39: u"dodesilyon", 42: u"tredesilyon", 45: u"katordesilyon", 48: u"kendesilyon", 51: u"seksdesilyon", 54: u"septendesilyon", 57: u"oktodesilyon", 60: u"novemdesilyon", 63: u"vigintilyon", } VOWELS = u"aıoueəiöü" VOWEL_TO_CARDINAL_SUFFIX_MAP = { **dict.fromkeys(["a", "ı"], "ıncı"), **dict.fromkeys(["e", "ə", "i"], "inci"), **dict.fromkeys(["o", "u"], "uncu"), **dict.fromkeys(["ö", "ü"], "üncü"), } VOWEL_TO_CARDINAL_NUM_SUFFIX_MAP = { **dict.fromkeys(["a", "ı"], "cı"), **dict.fromkeys(["e", "ə", "i"], "ci"), **dict.fromkeys(["o", "u"], "cu"), **dict.fromkeys(["ö", "ü"], "cü"), } CURRENCY_INTEGRAL = ('manat', 'manat') CURRENCY_FRACTION = ('qəpik', 'qəpik') CURRENCY_FORMS = {'AZN': (CURRENCY_INTEGRAL, CURRENCY_FRACTION)} def setup(self): super().setup() self.negword = u"mənfi" self.pointword = u"nöqtə" def to_cardinal(self, value): value_str = str(value) parts = value_str.split(".") integral_part = parts[0] fraction_part = parts[1] if len(parts) > 1 else "" if integral_part.startswith("-"): integral_part = integral_part[1:] # ignore minus sign here integral_part_in_words = self.int_to_word(integral_part) fraction_part_in_words = "" if not fraction_part else self.int_to_word( fraction_part, leading_zeros=True) value_in_words = integral_part_in_words if fraction_part: value_in_words = " ".join( [ integral_part_in_words, self.pointword, fraction_part_in_words ] ) if value < 0: value_in_words = " ".join([self.negword, value_in_words]) return value_in_words def to_ordinal(self, value): assert int(value) == value cardinal = self.to_cardinal(value) last_vowel = self._last_vowel(cardinal) assert last_vowel is not None suffix = self.VOWEL_TO_CARDINAL_SUFFIX_MAP[last_vowel] if cardinal.endswith(tuple(self.VOWELS)): cardinal = cardinal[:-1] ordinal = "".join([cardinal, suffix]) return ordinal def to_ordinal_num(self, value): assert int(value) == value cardinal = self.to_cardinal(value) last_vowel = self._last_vowel(cardinal) assert last_vowel is not None suffix = self.VOWEL_TO_CARDINAL_NUM_SUFFIX_MAP[last_vowel] ordinal_num = "-".join([str(value), suffix]) return ordinal_num def to_year(self, value): assert int(value) == value year = self.to_cardinal(abs(value)) if value < 0: year = " ".join(["e.ə.", year]) return year def pluralize(self, n, forms): form = 0 if n == 1 else 1 return forms[form] def int_to_word(self, num_str, leading_zeros=False): words = [] reversed_str = list(reversed(num_str)) for index, digit in enumerate(reversed_str): digit_int = int(digit) # calculate remainder after dividing index by 3 # because number is parsed by three digit chunks remainder_to_3 = index % 3 if remainder_to_3 == 0: if index > 0: if set(reversed_str[index:index+3]) != {'0'}: words.insert(0, self.POWERS_OF_TEN[index]) if digit_int > 0: # we say "min" not "bir min" if not (digit_int == 1 and index == 3): words.insert(0, self.DIGITS[digit_int]) elif remainder_to_3 == 1: if digit_int != 0: words.insert(0, self.DECIMALS[digit_int]) else: # remainder is 2 if digit_int > 0: words.insert(0, self.POWERS_OF_TEN[2]) # "yüz" if digit_int > 1: words.insert(0, self.DIGITS[digit_int]) if num_str == '0': words.append(self.DIGITS[0]) if leading_zeros: zeros_count = len(num_str) - len(str(int(num_str))) words[:0] = zeros_count * [self.DIGITS[0]] return " ".join(words) def _last_vowel(self, value): for char in value[::-1]: if char in self.VOWELS: return char num2words-0.5.14/num2words/lang_BE.py000066400000000000000000000271121473005321200173420ustar00rootroot00000000000000# Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2022, Sergei Ruzki. 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = "нуль" ONES_FEMININE = { 1: "адна", 2: "дзве", 3: "тры", 4: "чатыры", 5: "пяць", 6: "шэсць", 7: "сем", 8: "восем", 9: "дзевяць", } ONES = { "f": { 1: "адна", 2: "дзве", 3: "тры", 4: "чатыры", 5: "пяць", 6: "шэсць", 7: "сем", 8: "восем", 9: "дзевяць", }, "m": { 1: "адзін", 2: "два", 3: "тры", 4: "чатыры", 5: "пяць", 6: "шэсць", 7: "сем", 8: "восем", 9: "дзевяць", }, "n": { 1: "адно", 2: "два", 3: "тры", 4: "чатыры", 5: "пяць", 6: "шэсць", 7: "сем", 8: "восем", 9: "дзевяць", }, } TENS = { 0: "дзесяць", 1: "адзінаццаць", 2: "дванаццаць", 3: "трынаццаць", 4: "чатырнаццаць", 5: "пятнаццаць", 6: "шаснаццаць", 7: "сямнаццаць", 8: "васямнаццаць", 9: "дзевятнаццаць", } TWENTIES = { 2: "дваццаць", 3: "трыццаць", 4: "сорак", 5: "пяцьдзясят", 6: "шэсцьдзясят", 7: "семдзесят", 8: "восемдзесят", 9: "дзевяноста", } TWENTIES_ORD = ( ("дваццаць", "дваццаці"), ("трыццаць", "трыццаці"), ("сорак", "сарака"), ("пяцьдзясят", "пяцідзясяці"), ("шэсцьдзясят", "шaсцідзясяці"), ("семдзесят", "сямідзесяці"), ("восемдзесят", "васьмідзесяці"), ("дзевяноста", "дзевяноста"), ) HUNDREDS = { 1: "сто", 2: "дзвесце", 3: "трыста", 4: "чатырыста", 5: "пяцьсот", 6: "шэсцьсот", 7: "семсот", 8: "восемсот", 9: "дзевяцьсот", } THOUSANDS = { 1: ("тысяча", "тысячы", "тысяч"), # 10^3 2: ("мільён", "мільёны", "мільёнаў"), # 10^6 3: ("мільярд", "мільярды", "мільярдаў"), # 10^9 4: ("трыльён", "трыльёны", "трыльёнаў"), # 10^12 5: ("квадрыльён", "квадрыльёны", "квадрыльёнаў"), # 10^15 6: ("квінтыльён", "квінтыльёны", "квінтыльёнаў"), # 10^18 7: ("секстыльён", "секстыльёны", "секстыльёнаў"), # 10^21 8: ("сэптыльён", "сэптыльёны", "сэптыльёнаў"), # 10^24 9: ("актыльён", "актыльёны", "актыльёнаў"), # 10^27 10: ("нанільён", "нанільёны", "нанільёнаў"), # 10^30 } class Num2Word_BE(Num2Word_Base): CURRENCY_FORMS = { "RUB": ( ("расійскі рубель", "расійскія рублі", "расійскіх рублёў"), ("капейка", "капейкі", "капеек"), ), "EUR": (("еўра", "еўра", "еўра"), ("цэнт", "цэнты", "цэнтаў")), "USD": (("долар", "долары", "долараў"), ("цэнт", "цэнты", "цэнтаў")), "UAH": ( ("грыўна", "грыўны", "грыўнаў"), ("капейка", "капейкі", "капеек"), ), "KZT": (("тэнге", "тэнге", "тэнге"), ("тыйін", "тыйіны", "тыйінаў")), "BYN": ( ("беларускі рубель", "беларускія рублі", "беларускіх рублёў"), ("капейка", "капейкі", "капеек"), ), "UZS": (("сум", "сумы", "сумаў"), ("тыйін", "тыйіны", "тыйінаў")), "PLN": (("злоты", "злотых", "злотых"), ("грош", "грошы", "грошаў")), } def setup(self): self.negword = "мінус" self.pointword = "коска" self.ords = { "нуль": "нулявы", "адзін": "першы", "два": "другі", "тры": "трэці", "чатыры": "чацвёрты", "пяць": "пяты", "шэсць": "шосты", "сем": "сёмы", "восем": "восьмы", "дзевяць": "дзявяты", "сто": "соты", "тысяча": "тысячны", } self.ords_adjective = { "адзін": "адна", "адна": "адна", "дзве": "двух", "тры": "трох", "чатыры": "чатырох", "пяць": "пяці", "шэсць": "шасці", "сем": "сямі", "восем": "васьмі", "дзевяць": "дзевяцi", "сто": "ста", } def to_cardinal(self, number, gender="m"): n = str(number).replace(",", ".") if "." in n: left, right = n.split(".") if set(right) == {"0"}: leading_zero_count = 0 else: leading_zero_count = len(right) - len(right.lstrip("0")) decimal_part = (ZERO + " ") * leading_zero_count + self._int2word( int(right), gender ) return "{} {} {}".format( self._int2word(int(left), gender), self.pointword, decimal_part ) else: return self._int2word(int(n), gender) def pluralize(self, n, forms): if n % 100 < 10 or n % 100 > 20: if n % 10 == 1: form = 0 elif 5 > n % 10 > 1: form = 1 else: form = 2 else: form = 2 return forms[form] def to_ordinal(self, number, gender="m"): self.verify_ordinal(number) if isinstance(gender, bool) and gender: gender = "f" outwords = self.to_cardinal(number, gender).split(" ") lastword = outwords[-1].lower() try: if len(outwords) > 1: if outwords[-2] in self.ords_adjective: outwords[-2] = self.ords_adjective.get( outwords[-2], outwords[-2] ) elif outwords[-2] == "дзесяць": outwords[-2] = outwords[-2][:-1] + "і" if len(outwords) == 3: if outwords[-3] in ["адзін", "адна"]: outwords[-3] = "" lastword = self.ords[lastword] except KeyError: if lastword[:-3] in self.ords_adjective: lastword = ( self.ords_adjective.get(lastword[:-3], lastword) + "соты" ) elif lastword[-7:] == "дзесяць": lastword = "дзясяты" elif lastword[-9:] == "семдзесят": lastword = "сямідзясяты" elif lastword[-1] == "ь" or lastword[-2] == "ц": lastword = lastword[:-2] + "ты" elif lastword[-1] == "к": lastword = lastword.replace("о", "а") + "авы" elif lastword[-2] == "ч" or lastword[-1] == "ч": if lastword[-2] == "ч": lastword = lastword[:-1] + "ны" if lastword[-1] == "ч": lastword = lastword + "ны" elif lastword[-1] == "н" or lastword[-2] == "н": lastword = lastword[: lastword.rfind("н") + 1] + "ны" elif lastword[-3:] == "наў": lastword = lastword[: lastword.rfind("н") + 1] + "ны" elif lastword[-1] == "д" or lastword[-2] == "д": lastword = lastword[: lastword.rfind("д") + 1] + "ны" if gender == "f": if lastword[-2:] in [ "ці", ]: lastword = lastword[:-2] + "цяя" else: lastword = lastword[:-1] + "ая" if gender == "n": if lastword[-2:] in ["ці", "ца"]: lastword = lastword[:-2] + "цяе" else: lastword = lastword[:-1] + "ае" outwords[-1] = self.title(lastword) if len(outwords) == 2 and "адна" in outwords[-2]: outwords[-2] = outwords[-1] del outwords[-1] if len(outwords) > 1 and ( (any(x[0] in outwords[-1] for x in THOUSANDS.values())) or "тысяч" in outwords[-1] ): new_outwords = [] for _w in outwords: replacement = next( (x for x in TWENTIES_ORD if x[0] in _w), None ) if replacement: _w = _w.replace(replacement[0], replacement[1]) new_outwords.append(_w) outwords = ["".join(new_outwords)] return " ".join(outwords).strip() def _money_verbose(self, number, currency): gender = "m" if currency == "UAH": gender = "f" return self._int2word(number, gender) def _cents_verbose(self, number, currency): if currency in ("UAH", "RUB", "BYN"): gender = "f" else: gender = "m" return self._int2word(number, gender) def _int2word(self, n, gender="m"): if n < 0: return " ".join([self.negword, self._int2word(abs(n), gender)]) if n == 0: return ZERO words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: words.append(HUNDREDS[n3]) if n2 > 1: words.append(TWENTIES[n2]) if n2 == 1: words.append(TENS[n1]) elif n1 > 0: if i == 0: ones = ONES[gender] elif i == 1: ones = ONES["f"] # Thousands are feminine else: ones = ONES["m"] words.append(ones[n1]) if i > 0: words.append(self.pluralize(x, THOUSANDS[i])) return " ".join(words) num2words-0.5.14/num2words/lang_BN.py000066400000000000000000000210521473005321200173500ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Author: Mehedi Hasan Khondoker # Email: mehedihasankhondoker [at] gmail.com # Copyright (c) 2024, Mehedi Hasan Khondoker. All Rights Reserved. # This library is build for Bangladesh format Number to Word conversion. # You are welcome as contributor to the library. # 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. from decimal import Decimal RANKING = ['', 'প্রথম', 'দ্বিতীয়', 'তৃতীয়', 'চতুর্থ', 'পঞ্চম', 'ষষ্ঠ', 'সপ্তম', 'অষ্টম', 'নবম', 'দশম'] # pragma: no cover AKOK = ['', 'এক', 'দুই', 'তিন', 'চার', 'পাঁচ', 'ছয়', 'সাত', 'আট', 'নয়'] # pragma: no cover DOSOK = [ 'দশ', 'এগারো', 'বারো', 'তেরো', 'চৌদ্দ', 'পনের', 'ষোল', 'সতের', 'আঠারো', 'উনিশ', 'বিশ', 'একুশ', 'বাইশ', 'তেইশ', 'চব্বিশ', 'পঁচিশ', 'ছাব্বিশ', 'সাতাশ', 'আটাশ', 'উনত্রিশ', 'ত্রিশ', 'একত্রিশ', 'বত্রিশ', 'তেত্রিশ', 'চৌত্রিশ', 'পঁইত্রিশ', 'ছত্রিশ', 'সাতত্রিশ', 'আটত্রিশ', 'উনচল্লিশ', 'চল্লিশ', 'একচল্লিশ', 'বিয়াল্লিশ', 'তেতাল্লিশ', 'চৌচল্লিশ', 'পঁয়তাল্লিশ', 'ছেচল্লিশ', 'সাতচল্লিশ', 'আটচল্লিশ', 'উনপঞ্চাশ', 'পঞ্চাশ', 'একান্ন', 'বাহান্ন', 'তিপ্পান্ন', 'চুয়ান্ন', 'পঞ্চান্ন', 'ছাপ্পান্ন', 'সাতান্ন', 'আটান্ন', 'উনষাট', 'ষাট', 'একষট্টি', 'বাষট্টি', 'তেষট্টি', 'চৌষট্টি', 'পঁয়ষট্টি', 'ছিষট্টি', 'সাতষট্টি', 'আটষট্টি', 'উনসত্তর', 'সত্তর', 'একাত্তর ', 'বাহাত্তর', 'তিয়াত্তর', 'চুয়াত্তর', 'পঁচাত্তর', 'ছিয়াত্তর', 'সাতাত্তর', 'আটাত্তর', 'উনআশি', 'আশি', 'একাশি', 'বিরাশি', 'তিরাশি', 'চুরাশি', 'পঁচাশি', 'ছিয়াশি', 'সাতাশি', 'আটাশি', 'উননব্বই', 'নব্বই', 'একানব্বই', 'বিরানব্বই', 'তিরানব্বই', 'চুরানব্বই', 'পঁচানব্বই', 'ছিয়ানব্বই', 'সাতানব্বই', 'আটানব্বই', 'নিরানব্বই' ] # pragma: no cover HAZAR = ' হাজার ' # pragma: no cover LAKH = ' লাখ ' # pragma: no cover KOTI = ' কোটি ' # pragma: no cover MAX_NUMBER = 9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 # noqa: E501 # pragma: no cover class NumberTooLargeError(Exception): """Custom exception for numbers that are too large.""" pass class Num2Word_BN: @staticmethod def str_to_number(number): return abs(Decimal(str(number))) # pragma: no cover @staticmethod def parse_number(number: Decimal): dosomik = str(number - int(number)).split('.')[1:] dosomik_str = ''.join(dosomik) if dosomik else 0 return int(number), int(dosomik_str) @staticmethod def parse_paisa(number: Decimal): # 1-99 for paisa count so two digits are valid. paisa = str(number - int(number)).split('.')[1:] paisa_str = ''.join(paisa) if paisa else 0 # this is need, when we parse to decimal it removes trailing 0 . if paisa_str: paisa_str = str(int(paisa_str) * 100)[:2] return int(number), int(paisa_str) def _is_smaller_than_max_number(self, number): if MAX_NUMBER >= number: return True raise NumberTooLargeError(f'Too Large number maximum ' f'value={MAX_NUMBER}') def _dosomik_to_bengali_word(self, number): word = '' for i in str(number): word += ' ' + AKOK[int(i)] return word def _number_to_bengali_word(self, number): if number == 0: return 'শূন্য' words = '' if number >= 10 ** 7: words += self._number_to_bengali_word(number // 10 ** 7) + KOTI number %= 10 ** 7 if number >= 10 ** 5: words += self._number_to_bengali_word(number // 10 ** 5) + LAKH number %= 10 ** 5 if number >= 1000: words += self._number_to_bengali_word(number // 1000) + HAZAR number %= 1000 if number >= 100: words += AKOK[number // 100] + 'শত ' number %= 100 if 10 <= number <= 99: words += DOSOK[number - 10] + ' ' number = 0 if 0 < number < 10: words += AKOK[number] + ' ' return words.strip() def to_currency(self, val): """ This function represent a number to word in bangla taka and paisa. example: 1 = এক টাকা, 101 = একশত এক টাকা, 9999.15 = নয় হাজার নয়শত নিরানব্বই টাকা পনের পয়সা and so on. """ dosomik_word = None number = self.str_to_number(val) number, decimal_part = self.parse_paisa(number) self._is_smaller_than_max_number(number) if decimal_part > 0: dosomik_word = f' {self._number_to_bengali_word(decimal_part)} পয়সা' # noqa: E501 words = f'{self._number_to_bengali_word(number)} টাকা' if dosomik_word: return (words + dosomik_word).strip() return words.strip() def to_cardinal(self, number): """ This function represent a number to word in bangla. example: 1 = এক, 101 = একশত এক, 9999 = নয় হাজার নয়শত নিরানব্বই and so on. """ dosomik_word = None number = self.str_to_number(number) number, decimal_part = self.parse_number(number) self._is_smaller_than_max_number(number) if decimal_part > 0: dosomik_word = f' দশমিক{self._dosomik_to_bengali_word(decimal_part)}' # noqa: E501 words = self._number_to_bengali_word(number) if dosomik_word: return (words + dosomik_word).strip() return words.strip() def to_ordinal(self, number): return self.to_cardinal(number) def to_ordinal_num(self, number): """ This function represent a number to ranking in bangla. example: 1 = প্রথম, 2 = দ্বিতীয়, 1001 = এক হাজার একতম and so on. """ self._is_smaller_than_max_number(number) if number in range(1, 11): return RANKING[number] else: rank = self.to_cardinal(int(abs(number))) if rank.endswith('ত'): return rank + 'ম' return rank + 'তম' def to_year(self, number): """ This function represent a number to year in bangla. example: 2002 = দুই হাজার দুই সাল, 2024 = দুই হাজার চব্বিশ সাল and so on. """ self._is_smaller_than_max_number(number) return self.to_cardinal(int(abs(number))) + ' সাল' num2words-0.5.14/num2words/lang_CA.py000066400000000000000000000446471473005321200173530ustar00rootroot00000000000000from __future__ import division, print_function, unicode_literals import math from .lang_EU import Num2Word_EU GENERIC_DOLLARS = ('dòlar', 'dòlars') GENERIC_CENTS = ('centau', 'centaus') CURRENCIES_UNA = ( 'SLL', 'SEK', 'NOK', 'CZK', 'DKK', 'ISK', 'SKK', 'GBP', 'CYP', 'EGP', 'FKP', 'GIP', 'LBP', 'SDG', 'SHP', 'SSP', 'SYP', 'INR', 'IDR', 'LKR', 'MUR', 'NPR', 'PKR', 'SCR', 'ESP', 'TRY', 'ITL', ) CENTS_UNA = ('EGP', 'JOD', 'LBP', 'SDG', 'SSP', 'SYP') class Num2Word_CA(Num2Word_EU): CURRENCY_FORMS = { 'EUR': (('euro', 'euros'), ('cèntim', 'cèntims')), 'ESP': (('pesseta', 'pessetes'), ('cèntim', 'cèntims')), 'USD': (GENERIC_DOLLARS, ('centau', 'centaus')), 'PEN': (('sol', 'sols'), ('cèntim', 'cèntims')), 'CRC': (('colón', 'colons'), GENERIC_CENTS), 'AUD': (GENERIC_DOLLARS, GENERIC_CENTS), 'CAD': (GENERIC_DOLLARS, GENERIC_CENTS), 'GBP': (('lliura', 'lliures'), ('penic', 'penics')), 'RUB': (('ruble', 'rubles'), ('copec', 'copecs')), 'SEK': (('corona', 'corones'), ('öre', 'öre')), 'NOK': (('corona', 'corones'), ('øre', 'øre')), 'PLN': (('zloty', 'zlotys'), ('grosz', 'groszy')), 'MXN': (('peso', 'pesos'), GENERIC_CENTS), 'RON': (('leu', 'lei'), ('ban', 'bani')), 'INR': (('rupia', 'rupies'), ('paisa', 'paise')), 'HUF': (('fòrint', 'fòrints'), ('fillér', 'fillérs')), 'FRF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'CNY': (('iuan', 'iuans'), ('fen', 'jiao')), 'CZK': (('corona', 'corones'), ('haléř', 'haléřů')), 'NIO': (('córdoba', 'córdobas'), GENERIC_CENTS), 'VES': (('bolívar', 'bolívars'), ('cèntim', 'cèntims')), 'BRL': (('real', 'reals'), GENERIC_CENTS), 'CHF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'JPY': (('ien', 'iens'), ('sen', 'sen')), 'KRW': (('won', 'wons'), ('jeon', 'jeon')), 'KPW': (('won', 'wons'), ('chŏn', 'chŏn')), 'TRY': (('lira', 'lires'), ('kuruş', 'kuruş')), 'ZAR': (('rand', 'rands'), ('cèntim', 'cèntims')), 'KZT': (('tenge', 'tenge'), ('tin', 'tin')), 'UAH': (('hrívnia', 'hrívnies'), ('kopiika', 'kopíok')), 'THB': (('baht', 'bahts'), ('satang', 'satang')), 'AED': (('dirham', 'dirhams'), ('fils', 'fulūs')), 'AFN': (('afgani', 'afganis'), ('puli', 'puls')), 'ALL': (('lek', 'lekë'), ('qqindarka', 'qindarkë')), 'AMD': (('dram', 'drams'), ('luma', 'lumas')), 'ANG': (('florí', 'florins'), ('cèntim', 'cèntims')), 'AOA': (('kwanza', 'kwanzes'), ('cèntim', 'cèntims')), 'ARS': (('peso', 'pesos'), GENERIC_CENTS), 'AWG': (('florí', 'florins'), GENERIC_CENTS), 'AZN': (('manat', 'manats'), ('qəpik', 'qəpik')), 'BBD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BDT': (('taka', 'taka'), ('poisha', 'poisha')), 'BGN': (('lev', 'leva'), ('stotinka', 'stotinki')), 'BHD': (('dinar', 'dinars'), ('fils', 'fulūs')), 'BIF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'BMD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BND': (GENERIC_DOLLARS, GENERIC_CENTS), 'BOB': (('boliviano', 'bolivianos'), GENERIC_CENTS), 'BSD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BTN': (('ngultrum', 'ngultrums'), ('chetrum', 'chetrums')), 'BWP': (('pula', 'pula'), ('thebe', 'thebe')), 'BYN': (('ruble', 'rubles'), ('copec', 'copecs')), 'BYR': (('ruble', 'rubles'), ('copec', 'copecs')), 'BZD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'CDF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'CLP': (('peso', 'pesos'), GENERIC_CENTS), 'COP': (('peso', 'pesos'), GENERIC_CENTS), 'CUP': (('peso', 'pesos'), GENERIC_CENTS), 'CVE': (('escut', 'escuts'), GENERIC_CENTS), 'CYP': (('lliura', 'lliures'), ('cèntim', 'cèntims')), 'DJF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'DKK': (('corona', 'corones'), ('øre', 'øre')), 'DOP': (('peso', 'pesos'), GENERIC_CENTS), 'DZD': (('dinar', 'dinars'), ('cèntim', 'cèntims')), 'ECS': (('sucre', 'sucres'), GENERIC_CENTS), 'EGP': (('lliura', 'lliures'), ('piastre', 'piastres')), 'ERN': (('nakfa', 'nakfes'), ('cèntim', 'cèntims')), 'ETB': (('birr', 'birr'), ('cèntim', 'cèntims')), 'FJD': (GENERIC_DOLLARS, GENERIC_CENTS), 'FKP': (('lliura', 'lliures'), ('penic', 'penics')), 'GEL': (('lari', 'laris'), ('tetri', 'tetri')), 'GHS': (('cedi', 'cedis'), ('pesewa', 'pesewas')), 'GIP': (('lliura', 'lliures'), ('penic', 'penics')), 'GMD': (('dalasi', 'dalasis'), ('butut', 'bututs')), 'GNF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'GTQ': (('quetzal', 'quetzals'), GENERIC_CENTS), 'GYD': (GENERIC_DOLLARS, GENERIC_CENTS), 'HKD': (GENERIC_DOLLARS, GENERIC_CENTS), 'HNL': (('lempira', 'lempires'), GENERIC_CENTS), 'HRK': (('kuna', 'kuna'), ('lipa', 'lipa')), 'HTG': (('gourde', 'gourdes'), ('cèntim', 'cèntims')), 'IDR': (('rúpia', 'rúpies'), ('cèntim', 'cèntims')), 'ILS': (('xéquel', 'xéquels'), ('agorà', 'agorot')), 'IQD': (('dinar', 'dinars'), ('fils', 'fils')), 'IRR': (('rial', 'rials'), ('dinar', 'dinars')), 'ISK': (('corona', 'corones'), ('eyrir', 'aurar')), 'ITL': (('lira', 'lires'), ('cèntim', 'cèntims')), 'JMD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'JOD': (('dinar', 'dinars'), ('piastra', 'piastres')), 'KES': (('xiling', 'xílings'), ('cèntim', 'cèntims')), 'KGS': (('som', 'som'), ('tyiyn', 'tyiyn')), 'KHR': (('riel', 'riels'), ('cèntim', 'cèntims')), 'KMF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'KWD': (('dinar', 'dinars'), ('fils', 'fils')), 'KYD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'LAK': (('kip', 'kips'), ('at', 'at')), 'LBP': (('lliura', 'lliures'), ('piastra', 'piastres')), 'LKR': (('rúpia', 'rúpies'), ('cèntim', 'cèntims')), 'LRD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'LSL': (('loti', 'maloti'), ('sente', 'lisente')), 'LTL': (('lita', 'litai'), ('cèntim', 'cèntims')), 'LYD': (('dinar', 'dinars'), ('dírham', 'dírhams')), 'MAD': (('dírham', 'dirhams'), ('cèntim', 'cèntims')), 'MDL': (('leu', 'lei'), ('ban', 'bani')), 'MGA': (('ariary', 'ariary'), ('iraimbilanja', 'iraimbilanja')), 'MKD': (('denar', 'denari'), ('deni', 'deni')), 'MMK': (('kyat', 'kyats'), ('pya', 'pyas')), 'MNT': (('tögrög', 'tögrög'), ('möngö', 'möngö')), 'MOP': (('pataca', 'pataques'), ('avo', 'avos')), 'MRO': (('ouguiya', 'ouguiya'), ('khoums', 'khoums')), 'MRU': (('ouguiya', 'ouguiya'), ('khoums', 'khoums')), 'MUR': (('rupia', 'rúpies'), ('cèntim', 'cèntims')), 'MVR': (('rufiyaa', 'rufiyaa'), ('laari', 'laari')), 'MWK': (('kwacha', 'kwacha'), ('tambala', 'tambala')), 'MYR': (('ringgit', 'ringgits'), ('sen', 'sens')), 'MZN': (('metical', 'meticals'), GENERIC_CENTS), 'NAD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'NGN': (('naira', 'naires'), ('kobo', 'kobos')), 'NPR': (('rupia', 'rupies'), ('paisa', 'paises')), 'NZD': (GENERIC_DOLLARS, GENERIC_CENTS), 'OMR': (('rial', 'rials'), ('baisa', 'baisa')), 'PAB': (GENERIC_DOLLARS, ('centésimo', 'centésimos')), 'PGK': (('kina', 'kina'), ('toea', 'toea')), 'PHP': (('peso', 'pesos'), GENERIC_CENTS), 'PKR': (('rupia', 'rupies'), ('paisa', 'paise')), 'PLZ': (('zloty', 'zlotys'), ('grosz', 'groszy')), 'PYG': (('guaraní', 'guaranís'), ('cèntim', 'cèntims')), 'QAR': (('rial', 'rials'), ('dírham', 'dírhams')), 'QTQ': (('quetzal', 'quetzals'), GENERIC_CENTS), 'RSD': (('dinar', 'dinars'), ('para', 'para')), 'RUR': (('ruble', 'rubles'), ('copec', 'copecs')), 'RWF': (('franc', 'francs'), ('cèntim', 'cèntims')), 'SAR': (('riyal', 'riyals'), ('hàl·lala', 'hàl·lalat')), 'SBD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'SCR': (('rupia', 'rupies'), ('cèntim', 'cèntims')), 'SDG': (('lliura', 'lliures'), ('piastre', 'piastres')), 'SGD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'SHP': (('lliura', 'lliures'), ('penic', 'penics')), 'SLL': (('leonE', 'leones'), ('cèntim', 'cèntims')), 'SRD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'SSP': (('lliura', 'lliures'), ('piastre', 'piastres')), 'STD': (('dobra', 'dobrAs'), ('cèntim', 'cèntims')), 'SVC': (('colón', 'colons'), GENERIC_CENTS), 'SYP': (('lliura', 'lliures'), ('piastre', 'piastres')), 'SZL': (('lilangeni', 'emalangeni'), ('cèntim', 'cèntims')), 'TJS': (('somoni', 'somoni'), ('diram', 'diram')), 'TMT': (('manat', 'manats'), ('teňňesi', 'teňňesi')), 'TND': (('dinar', 'dinars'), ('mil·lim', 'mil·limat')), 'TOP': (('paanga', 'paangas'), ('seniti', 'seniti')), 'TTD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'TWD': (('nou dòlar', 'nous dòlars'), ('fen', 'fen')), 'TZS': (('xíling', 'xílings'), ('cèntim', 'cèntims')), 'UGX': (('xíling', 'xílings'), ('cèntim', 'cèntims')), 'UYU': (('peso', 'pesos'), ('centèsim', 'centèsims')), 'UZS': (('som', 'som'), ('tiyin', 'tiyin')), 'VND': (('dong', 'dongs'), ('xu', 'xu')), 'VUV': (('vatu', 'vatus'), ('cèntim', 'cèntims')), 'WST': (('tala', 'tala'), ('sene', 'sene')), 'XAF': (('franc CFA', 'francs CFA'), ('cèntim', 'cèntims')), 'XCD': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'XOF': (('franc CFA', 'francs CFA'), ('cèntim', 'cèntims')), 'XPF': (('franc CFP', 'francs CFP'), ('cèntim', 'cèntims')), 'YER': (('rial', 'rials'), ('fils', 'fils')), 'YUM': (('dinar', 'dinars'), ('para', 'para')), 'ZMW': (('kwacha', 'kwacha'), ('ngwee', 'ngwee')), 'ZWL': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), 'ZWL': (GENERIC_DOLLARS, ('cèntim', 'cèntims')), } GIGA_SUFFIX = None MEGA_SUFFIX = "ilió" def setup(self): lows = ["quadr", "tr", "b", "m"] self.high_numwords = self.gen_high_numwords([], [], lows) self.negword = "menys " self.pointword = "punt" self.errmsg_nonnum = "type(%s) no és [long, int, float]" self.errmsg_floatord = "El float %s no pot ser tractat com un" \ " ordinal." self.errmsg_negord = "El número negatiu %s no pot ser tractat" \ " com un ordinal." self.errmsg_toobig = "abs(%s) ha de ser inferior a %s." self.gender_stem = "è" self.exclude_title = ["i", "menys", "punt"] self.mid_numwords = [ (1000, "mil"), (100, "cent"), (90, "noranta"), (80, "vuitanta"), (70, "setanta"), (60, "seixanta"), (50, "cinquanta"), (40, "quaranta"), (30, "trenta"), ] self.low_numwords = [ "vint-i-nou", "vint-i-vuit", "vint-i-set", "vint-i-sis", "vint-i-cinc", "vint-i-quatre", "vint-i-tres", "vint-i-dos", "vint-i-un", "vint", "dinou", "divuit", "disset", "setze", "quinze", "catorze", "tretze", "dotze", "onze", "deu", "nou", "vuit", "set", "sis", "cinc", "quatre", "tres", "dos", "un", "zero", ] self.mid_num = { 1000: "mil", 100: "cent", 90: "noranta", 80: "vuitanta", 70: "setanta", 60: "seixanta", 50: "cinquanta", 40: "quaranta", 30: "trenta", 20: "vint", 10: "deu", } self.low_num = { 0: "zero", 1: "un", 2: "dos", 3: "tres", 4: "quatre", 5: "cinc", 6: "sis", 7: "set", 8: "vuit", 9: "nou", 10: "deu", 11: "onze", 12: "dotze", 13: "tretze", 14: "catorze", 15: "quinze", 16: "setze", 17: "disset", 18: "divuit", 19: "dinou", 20: "vint", 21: "vint-i-un", 22: "vint-i-dos", 23: "vint-i-tres", 24: "vint-i-quatre", 25: "vint-i-cinc", 26: "vint-i-sis", 27: "vint-i-set", 28: "vint-i-vuit", 29: "vint-i-nou", } self.ords = { 1: "primer", 2: "segon", 3: "tercer", 4: "quart", 5: "cinqu", 6: "sis", 7: "set", 8: "vuit", 9: "nov", 10: "des", 11: "onz", 12: "dotz", 13: "tretz", 14: "catorz", 15: "quinz", 16: "setz", 17: "disset", 18: "divuit", 19: "dinov", 20: "vint", 30: "trent", 40: "quarant", 50: "cinquant", 60: "seixant", 70: "setant", 80: "vuitant", 90: "norant", 100: "cent", 200: "dos-cent", 300: "tres-cent", 400: "quatre-cent", 500: "cinc-cent", 600: "sis-cent", 700: "set-cent", 800: "vuit-cent", 900: "nou-cent", 1e3: "mil", 1e6: "milion", 1e9: "mil milion", 1e12: "bilion", 1e15: "mil bilion", } self.ords_2 = {1: "1r", 2: "2n", 3: "3r", 4: "4t"} self.ords_3 = { 1: "unè", 2: "dosè", 3: "tresè", 4: "quatrè", 5: "cinquè", 6: "sisè", 7: "setè", 8: "vuitè", 9: "novè", } def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next ctext = "un" if nnum < cnum: if cnum < 100: return "%s-%s" % (ctext, ntext), cnum + nnum elif nnum == 1: return "%s %s" % (ctext, ntext), cnum + nnum elif cnum == 100: return "%s %s" % (ctext, ntext), cnum + nnum else: return "%s %s" % (ctext, ntext), cnum + nnum elif (not nnum % 1000000) and cnum > 1: ntext = ntext[:-3] + "lions" if nnum == 100: ntext += "s" ctext += "-" else: ntext = " " + ntext return (ctext + ntext, cnum * nnum) def to_ordinal(self, value): self.verify_ordinal(value) if value == 0: text = "" elif value < 5: text = self.ords[value] elif value <= 20: text = "%s%s" % (self.ords[value], self.gender_stem) elif value <= 30: frac = value % 10 text = "%s%s%s" % (self.ords[20], "-i-", self.ords_3[frac]) elif value < 100: dec = (value // 10) * 10 text = "%s%s%s%s" % (self.ords[dec], "a", "-", self.ords_3[value - dec]) elif value == 1e2: text = "%s%s" % (self.ords[value], self.gender_stem) elif value < 2e2: cen = (value // 100) * 100 text = "%s %s" % (self.ords[cen], self.to_ordinal(value - cen)) elif value < 1e3: cen = (value // 100) * 100 text = "%s%s %s" % (self.ords[cen], "s", self.to_ordinal(value - cen)) elif value == 1e3: text = "%s%s" % (self.ords[value], self.gender_stem) elif value < 1e6: dec = 1000 ** int(math.log(int(value), 1000)) high_part, low_part = divmod(value, dec) cardinal = self.to_cardinal(high_part) if high_part != 1 else "" text = "%s %s %s" % (cardinal, self.ords[dec], self.to_ordinal(low_part)) elif value < 1e18: dec = 1000 ** int(math.log(int(value), 1000)) high_part, low_part = divmod(value, dec) cardinal = self.to_cardinal(high_part) if high_part != 1 else "" text = "%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem, self.to_ordinal(low_part)) else: part1 = self.to_cardinal(value) text = "%s%s" % (part1[:-1], "onè") return text.strip() def to_ordinal_num(self, value): self.verify_ordinal(value) if value not in self.ords_2: return "%s%s" % (value, "è" if self.gender_stem == "è" else "a") else: return self.ords_2[value] def to_currency(self, val, currency="EUR", cents=True, separator=" amb", adjective=False): result = super(Num2Word_CA, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective ) list_result = result.split(separator + " ") if currency in CURRENCIES_UNA: list_result[0] = list_result[0].replace("un", "una") list_result[0] = list_result[0].replace("dos", "dues") list_result[0] = list_result[0].replace("cents", "centes") list_result[0] = list_result[0].replace("vint-i-un", "vint-i-un") list_result[0] = list_result[0].replace(" i un", "-un") list_result[0] = list_result[0].replace("un", "un") if currency in CENTS_UNA: list_result[1] = list_result[1].replace("un", "una") list_result[1] = list_result[1].replace("dos", "dues") list_result[1] = list_result[1].replace("vint-i-un", "vint-i-una") list_result[1] = list_result[1].replace("un", "un") result = (separator + " ").join(list_result) return result num2words-0.5.14/num2words/lang_CE.py000066400000000000000000000372401473005321200173460ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2023, Johannes Heinecke. All Rights Reserved. # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301 USA from __future__ import unicode_literals from .currency import parse_currency_parts from .lang_EU import Num2Word_EU # Chechen numbers inflect in case if without noun or # use a special oblique ending when followed by a counted noun # 4, 14, 40 and composites thereof agree in class (gender) with the # noun. Chechen has 6 classes which are indicated by the initial # letter of 4, 14 and 40. By default it is "д" but # it can also be "б", "й" or "в". # Indicate the needed class prefix as follows # num2words(4, lang='ce', case="abs", clazz="б") CARDINALS = { "casenames": { "abs": "Им.", "gen": "Род.", "dat": "Дат.", "erg": "Эрг;", "instr": "Твор.", "mat": "Вещ.", "comp": "Сравнит.", "all": "Местн.", }, "casesuffix_cons": { # to be added to numerals with final consonant "gen": "аннан", "dat": "анна", "erg": "амма", "instr": "анца", "mat": "аннах", "comp": "аннал", "all": "анга", "obl": "ан", "ORD": "алгӀа", }, "casesuffix_voc": { # to be added to numerals with final vowel "gen": "ннан", "dat": "нна", "erg": "мма", "instr": "нца", "mat": "ннах", "comp": "ннал", "all": "нга", "obl": "н", "ORD": "лгӀа", }, 0: { "attr": "ноль", "abs": "ноль", "gen": "нолан", "dat": "нолана", "erg": "ноло", "instr": "ноланца", "mat": "ноланах", "comp": "ноланал", "all": "ноланга", }, 1: { "attr": "цхьа", # in front of nouns in ABS "obl": "цхьана", # with nouns in other cases than ABS "abs": "цхьаъ", "gen": "цхьаннан", "dat": "цхьанна", "erg": "цхьамма", "instr": "цхьаьнца", "mat": "цхьаннах", "comp": "цхьаннал", "all": "цхаьнга", "ORD": "цхьалгӀа", }, 2: { "attr": "ши", # in front of 100, 1000 "obl": "шина", "abs": "шиъ", "gen": "шиннан", "dat": "шинна", "erg": "шимма", "instr": "шинца", "mat": "шиннах", "comp": "шиннал", "all": "шинга", "ORD": "шолгӀа", }, 3: { "attr": "кхо", "obl": "кхона", "abs": "кхоъ", "gen": "кхааннан", "dat": "кхаанна", "erg": "кхаамма", "instr": "кхаанца", "mat": "кхааннах", "comp": "кхааннал", "all": "кхаанга", "ORD": "кхоалгӀа", }, 4: { "attr": "д*и", "obl": "д*еа", "abs": "д*иъ", "gen": "д*еаннан", "dat": "д*еанна", "erg": "д*еамма", "instr": "д*еанца", "mat": "д*еаннах", "comp": "д*еаннал", "all": "д*еанга", "ORD": "д*оьалгӀа", }, 5: { "attr": "пхи", "obl": "пхеа", "abs": "пхиъ", "gen": "пхеаннан", "dat": "пхеанна", "erg": "пхеамма", "instr": "нхеанца", "mat": "пхеаннах", "comp": "пхеаннал", "all": "пхеанга", "ORD": "пхоьалгӀа", }, 6: { "abs": "ялх", "attr": "ялх", "ORD": "йолхалгӀа", }, 7: { "abs": "ворхӀ", "attr": "ворхӀ", "ORD": "ворхӀалгӀа", }, 8: { "abs": "бархӀ", "attr": "бархӀ", "ORD": "борхӀалӀа", }, 9: { "abs": "исс", "attr": "исс", "ORD": "уьссалгӀа", }, 10: { "attr": "итт", "abs": "итт", "gen": "иттаннан", "dat": "иттанна", "erg": "иттамма", "instr": "иттанца", "mat": "иттаннах", "comp": "иттаннал", "all": "иттанга", "ORD": "уьтталгӀа", }, 11: { "abs": "цхьайтта", "attr": "цхьайтта", "ORD": "цхьайтталгӀа", }, 12: { "abs": "шийтта", "attr": "шийтта", "ORD": "шийтталга", }, 13: { "abs": "кхойтта", "attr": "кхойтта", "ORD": "кхойтталгӀа", }, 14: { "abs": "д*ейтта", "attr": "д*ейтта", "ORD": "д*ейтталгӀа", }, 15: { "abs": "пхийтта", "attr": "пхийтта", "ORD": "пхийтталгӀа", }, 16: { "abs": "ялхитта", "attr": "ялхитта", "ORD": "ялхитталгӀа", }, 17: { "abs": "вуьрхӀитта", "attr": "вуьрхӀитта", "ORD": "вуьрхӀитталгӀа", }, 18: { "abs": "берхӀитта", "attr": "берхӀитта", "ORD": "берхитталӀа", }, 19: { "abs": "ткъайесна", "attr": "ткъайесна", "ORD": "ткъаесналгӀа", }, 20: { "abs": "ткъа", "gen": "ткъаннан", "dat": "ткъанна", "erg": "ткъамма", "instr": "ткъанца", "mat": "ткъаннах", "comp": "ткъаннал", "all": "ткъанга", "attr": "ткъе", "ORD": "ткъолгӀа", }, 40: { "abs": "шовзткъа", "attr": "шовзткъе", "ORD": "шовзткъалгІа", }, 60: { "abs": "кхузткъа", "attr": "кхузткъе", "ORD": "кхузткъалгІа", }, 80: { "abs": "дезткъа", "attr": "дезткъе", "ORD": "дезткъалгІа", }, 100: { "attr": "бӀе", "abs": "бӀе", "obl": "бӀен", "gen": "бӀеннан", "dat": "бӀенна", "erg": "бӀемма", "instr": "бӀенца", "mat": "бӀеннах", "comp": "бӀеннал", "all": "бӀенга", "ORD": "бІолгІа", }, 1000: { "attr": "эзар", "abs": "эзар", "obl": "эзаран", "gen": "эзарнан", "dat": "эзарна", "erg": "эзарно", "instr": "эзарнаца", "mat": "эзарнах", "comp": "эзарнал", "all": "эзаранга", "ORD": "эзарлагІа", }, 1000000: { "attr": "миллион", "abs": "миллион", "ORD": "миллионалгІа", }, } ILLIONS = { 6: { "attr": "миллион", "abs": "миллион", "ORD": "миллионалгІа", }, 9: { "attr": "миллиард", "abs": "миллиард", "ORD": "миллиардалгІа", }, 12: { "attr": "биллион", "abs": "биллион", "ORD": "биллионалгІа", }, 15: { "attr": "биллиард", "abs": "биллиард", "ORD": "биллиардалгІа", }, 18: { "attr": "триллион", "abs": "триллион", "ORD": "триллионалгІа", }, 21: { "attr": "триллиард", "abs": "триллиард", "ORD": "триллиардалгІа", }, 24: { "attr": "квадриллион", "abs": "квадриллион", "ORD": "квадриллионалгІа", }, 27: { "attr": "квадриллиард", "abs": "квадриллиард", "ORD": "квадриллиардалгІа", }, 30: { "attr": "квинтиллион", "abs": "квинтиллион", "ORD": "квинтиллионалгІа", }, 33: { "attr": "квинтиллиард", "abs": "квинтиллиард", "ORD": "квинтиллиардалгІа", }, } MINUS = "минус" # DECIMALPOINT = "запятая" # check ! DECIMALPOINT = "а" class Num2Word_CE(Num2Word_EU): CURRENCY_FORMS = { # currency code: (sg, pl), (sg, pl) "EUR": (("Евро", "Евро"), ("Сент", "Сенташ")), "RUB": (("Сом", "Сомаш"), ("Кепек", "Кепекаш")), "USD": (("Доллар", "Доллараш"), ("Сент", "Сенташ")), "GBP": (("Фунт", "Фунташ"), ("Пенни", "Пенни")), } def setup(self): Num2Word_EU.setup(self) self.negword = "минус" self.pointword = "запятая" # check ! # self.errmsg_nonnum = ( # u"Seulement des nombres peuvent être convertis en mots." # ) # self.errmsg_toobig = ( # u"Nombre trop grand pour être converti en mots (abs(%s) > %s)." # ) # self.exclude_title = ["et", "virgule", "moins"] self.mid_numwords = [] self.low_numwords = [] self.ords = {} def to_ordinal(self, number, clazz="д"): # implement here your code. number is the integer to # be transformed into an ordinal as a word (str) # which is returned return self.to_cardinal(number, clazz=clazz, case="ORD") def to_cardinal(self, number, clazz="д", case="abs"): if isinstance(number, float): entires = self.to_cardinal(int(number)) float_part = str(number).split(".")[1] postfix = " ".join( # Drops the trailing zero and comma [self.to_cardinal(int(c)) for c in float_part] ) return entires + " " + DECIMALPOINT + " " + postfix elif number < 20: return self.makecase(number, case, clazz) elif number < 100: twens = number // 20 units = number % 20 base = twens * 20 if units == 0: return self.makecase(number, case, clazz) else: twenties = self.makecase(base, "attr", clazz) rest = self.to_cardinal(units, clazz=clazz, case=case) return twenties + " " + rest.replace("д*", clazz) elif number < 1000: hundreds = number // 100 tens = number % 100 if hundreds > 1: hundert = ( CARDINALS[hundreds]["attr"].replace("д*", clazz) + " " ) else: hundert = "" if tens != 0: rest = self.to_cardinal(tens, clazz=clazz, case=case) return hundert + CARDINALS[100]["abs"] + " " + rest else: return hundert + self.makecase(100, case, clazz) elif number < 1000000: thousands = number // 1000 hundert = number % 1000 if hundert > 0: tcase = "attr" else: tcase = case if thousands > 1: tausend = ( self.to_cardinal(thousands, clazz=clazz, case="attr") + " " + CARDINALS[1000][tcase] ) else: tausend = self.makecase(1000, tcase, clazz) if hundert != 0: rest = " " + self.to_cardinal(hundert, clazz=clazz, case=case) else: rest = "" return tausend + rest elif number < 10**34: out = [] for pot in reversed([6, 9, 12, 15, 18, 21, 24, 27, 30, 33]): # 3 digits of billion, trillion etc step = number // 10**pot % 1000 if step > 0: words = self.to_cardinal(step, clazz=clazz, case="attr") out.append(words + " " + ILLIONS[pot]["attr"]) rest = number % 10**6 if rest: out.append(self.to_cardinal(rest, clazz=clazz, case=case)) return " ".join(out) return "NOT IMPLEMENTED" def _money_verbose(self, number, currency, case): mcase = "attr" if case != "abs": mcase = "obl" return self.to_cardinal(number, case=mcase) def _cents_verbose(self, number, currency, case): mcase = "attr" if case != "abs": mcase = "obl" return self.to_cardinal(number, case=mcase) def to_currency( self, val, currency="RUB", cents=True, separator=",", adjective=False, case="abs", ): """ Args: val: Numeric value currency (str): Currency code cents (bool): Verbose cents separator (str): Cent separator adjective (bool): Prefix currency name with adjective Returns: str: Formatted string """ left, right, is_negative = parse_currency_parts(val) try: cr1, cr2 = self.CURRENCY_FORMS[currency] devise = cr1[0] centime = cr2[0] except KeyError: raise NotImplementedError( 'Currency code "%s" not implemented for "%s"' % (currency, self.__class__.__name__) ) minus_str = "%s " % self.negword.strip() if is_negative else "" money_str = self._money_verbose(left, currency, case) cents_str = ( self._cents_verbose(right, currency, case) if cents else self._cents_terse(right, currency) ) return "%s%s %s%s %s %s" % ( minus_str, money_str, devise, # always singular separator, cents_str, centime, ) def to_ordinal_num(self, number): self.verify_ordinal(number) return str(number) + "-й" def to_year(self, year, case="abs"): return self.to_cardinal(year, case=case) def makecase(self, number, case, clazz): # print("ZZZZ", number, CARDINALS[number]) if case in CARDINALS[number]: return CARDINALS[number][case].replace("д*", clazz) else: if CARDINALS[number]["abs"][-1] in "а": return ( CARDINALS[number]["abs"].replace("д*", clazz) + CARDINALS["casesuffix_voc"][case] ) else: return ( CARDINALS[number]["abs"].replace("д*", clazz) + CARDINALS["casesuffix_cons"][case] ) num2words-0.5.14/num2words/lang_CS.py000066400000000000000000000103151473005321200173560ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = ('nula',) ONES = { 1: ('jedna',), 2: ('dva',), 3: ('tři',), 4: ('čtyři',), 5: ('pět',), 6: ('šest',), 7: ('sedm',), 8: ('osm',), 9: ('devět',), } TENS = { 0: ('deset',), 1: ('jedenáct',), 2: ('dvanáct',), 3: ('třináct',), 4: ('čtrnáct',), 5: ('patnáct',), 6: ('šestnáct',), 7: ('sedmnáct',), 8: ('osmnáct',), 9: ('devatenáct',), } TWENTIES = { 2: ('dvacet',), 3: ('třicet',), 4: ('čtyřicet',), 5: ('padesát',), 6: ('šedesát',), 7: ('sedmdesát',), 8: ('osmdesát',), 9: ('devadesát',), } HUNDREDS = { 1: ('sto',), 2: ('dvěstě',), 3: ('třista',), 4: ('čtyřista',), 5: ('pětset',), 6: ('šestset',), 7: ('sedmset',), 8: ('osmset',), 9: ('devětset',), } THOUSANDS = { 1: ('tisíc', 'tisíce', 'tisíc'), # 10^3 2: ('milion', 'miliony', 'milionů'), # 10^6 3: ('miliarda', 'miliardy', 'miliard'), # 10^9 4: ('bilion', 'biliony', 'bilionů'), # 10^12 5: ('biliarda', 'biliardy', 'biliard'), # 10^15 6: ('trilion', 'triliony', 'trilionů'), # 10^18 7: ('triliarda', 'triliardy', 'triliard'), # 10^21 8: ('kvadrilion', 'kvadriliony', 'kvadrilionů'), # 10^24 9: ('kvadriliarda', 'kvadriliardy', 'kvadriliard'), # 10^27 10: ('quintillion', 'quintilliony', 'quintillionů'), # 10^30 } class Num2Word_CS(Num2Word_Base): CURRENCY_FORMS = { 'CZK': ( ('koruna', 'koruny', 'korun'), ('halíř', 'halíře', 'haléřů') ), 'EUR': ( ('euro', 'euro', 'euro'), ('cent', 'centy', 'centů') ), } def setup(self): self.negword = "mínus" self.pointword = "celá" def to_cardinal(self, number): n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + self._int2word(int(right))) return u'%s %s %s' % ( self._int2word(int(left)), self.pointword, decimal_part ) else: return self._int2word(int(n)) def pluralize(self, n, forms): if n == 1: form = 0 elif 5 > n % 10 > 1 and (n % 100 < 10 or n % 100 > 20): form = 1 else: form = 2 return forms[form] def to_ordinal(self, number): raise NotImplementedError() def _int2word(self, n): if n == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: words.append(HUNDREDS[n3][0]) if n2 > 1: words.append(TWENTIES[n2][0]) if n2 == 1: words.append(TENS[n1][0]) elif n1 > 0 and not (i > 0 and x == 1): words.append(ONES[n1][0]) if i > 0: words.append(self.pluralize(x, THOUSANDS[i])) return ' '.join(words) num2words-0.5.14/num2words/lang_CY.py000066400000000000000000000471751473005321200174020ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2023, Johannes Heinecke. All Rights Reserved. # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301 USA from __future__ import unicode_literals from .currency import parse_currency_parts from .lang_EU import Num2Word_EU # Welsh numerals differs to many other languages since the counted # object does not follow the numeral but is inserted between # e.g. "23 hours" is # tri awr ar hugain # 3 hour on twenty # in addition to that some numeral trigger a mutation on the following word # either another numeral or the counted object # (https://en.wikipedia.org/wiki/Consonant_mutation#Welsh) # e.g. "23 dogs" (aspirated mutation, c -> ch) # tri chi ar hugain # 3 dog on twenty # but "22 dogs" (soft mutation, c -> g) # dau gi ar hugain # 2 dog on twenty # and "24 dogs" (no mutation) # pedwar ci ar hugain # 4 dog on twenty # (BTW, the counted word is always in singular when following a numeral) # numerals are mutated as well # e.g. "300" # tri chant # 3 hundred # "200" # dau gant # 2 hundred # "500" # pump cant # 5 hundreds # the numerals for 2, 3 and 4 are different in function of gender (MASC, FEM) # 2 cats # dwy gath # 2 dogs # dau gi # 2000 # dwy fil # 3000 # tair mil # to add the counted object in the correct position use # num2words(17, lang="cy", counted="ci", gender="masc") # num2words(17, lang="cy", counted="cath", gender="fem") # if the number is > 99, use plural form of counted object # num2words(117, lang="cy", counted="cathod", gender="fem") # Globals # ------- OBJ = "__OBJECT__" CARDINAL_WORDS = { # masc, fem, triggers mutation 0: [("dim", None), (OBJ, None)], 1: [("un", None), (OBJ, None)], 2: [("dau", "SM"), (OBJ, None)], 3: [("tri", "AM"), (OBJ, None)], 4: [("pedwar", None), (OBJ, None)], 5: [("pump", None), (OBJ, None)], 6: [("chwech", "AM"), (OBJ, None)], 7: [("saith", None), (OBJ, None)], 8: [("wyth", None), (OBJ, None)], 9: [("naw", None), (OBJ, None)], 10: [("deg", None), (OBJ, None)], 11: [("un", None), (OBJ, None), ("ar ddeg", None)], 12: [("deuddeg", None), (OBJ, None)], 13: [("tri", "AM"), (OBJ, None), ("ar ddeg", None)], 14: [("pedwar", None), (OBJ, None), ("ar ddeg", None)], 15: [("pymtheg", None), (OBJ, None)], 16: [("un", None), (OBJ, None), ("ar bymtheg", None)], 17: [("dau", "SM"), (OBJ, None), ("ar bymtheg", None)], 18: [("deunaw", None), (OBJ, None)], 19: [("pedwar", None), ("ar bymtheg", None)], } CARDINAL_WORDS_FEM = { # masc, fem, triggers mutation 0: [("dim", None), (OBJ, None)], 1: [("un", None), (OBJ, None)], 2: [("dwy", "SM"), (OBJ, None)], 3: [("tair", None), (OBJ, None)], 4: [("pedair", None), (OBJ, None)], 5: [("pump", None), (OBJ, None)], 6: [("chwech", "AM"), (OBJ, None)], 7: [("saith", None), (OBJ, None)], 8: [("wyth", None), (OBJ, None)], 9: [("naw", None), (OBJ, None)], 10: [("deg", None), (OBJ, None)], 11: [("un", None), (OBJ, None), ("ar ddeg", None)], 12: [("deuddeg", None), (OBJ, None)], 13: [("tair", None), (OBJ, None), ("ar ddeg", None)], 14: [("pedair", None), (OBJ, None), ("ar ddeg", None)], 15: [("pymtheg", None), (OBJ, None)], 16: [("un", None), (OBJ, None), ("ar bymtheg", None)], 17: [("dwy", "SM"), (OBJ, None), ("ar bymtheg", None)], 18: [("deunaw", None), (OBJ, None)], 19: [("pedair", None), ("ar bymtheg", None)], } MILLION_WORDS = { 3: ("mil", None), 6: ("miliwn", None), 9: ("biliwn", None), 12: ("triliwn", None), 15: ("cwadriliwn", None), 18: ("cwintiliwn", None), 21: ("secsttiliwn", None), 24: ("septiliwn", None), 27: ("octiliwn", None), 30: ("noniliwn", None), 33: ("dengiliwn", None), } ORDINAL_WORDS = { 0: [("dimfed", None), (OBJ, None)], 1: [(OBJ, None), ("cyntaf", None)], 2: [("ail", "SM"), (OBJ, None)], 3: [("trydydd", None), (OBJ, None)], 4: [("pedwerydd", None), (OBJ, None)], 5: [("pumed", None), (OBJ, None)], 6: [("chweched", None), (OBJ, None)], 7: [("saithfed", None), (OBJ, None)], 8: [("wythfed", None), (OBJ, None)], 9: [("nawfed", None), (OBJ, None)], 10: [("degfed", None), (OBJ, None)], 11: [("unfed", "SM"), (OBJ, None), ("ar ddeg", None)], 12: [("deuddegfed", None), (OBJ, None)], 13: [("trydydd", None), (OBJ, None), ("ar ddeg", None)], 14: [("pedwerydd", None), (OBJ, None), ("ar ddeg", None)], 15: [("pymthegfed", None), (OBJ, None)], 16: [("unfed", None), (OBJ, None), ("ar bymtheg", None)], 17: [("ail", "SM"), (OBJ, None), ("ar bymtheg", None)], 18: [("deunawfed", None), (OBJ, None)], 19: [("pedwerydd", None), (OBJ, None), ("ar bymtheg", None)], } ORDINAL_WORDS_FEM = { 0: [("dimfed", None), (OBJ, None)], 1: [(OBJ, None), ("gyntaf", None)], 2: [("ail", "SM"), (OBJ, None)], 3: [("trydedd", "SM"), (OBJ, None)], 4: [("pedwaredd", "SM"), (OBJ, None)], 5: [("pumed", None), (OBJ, None)], 6: [("chweched", None), (OBJ, None)], 7: [("saithfed", None), (OBJ, None)], 8: [("wythfed", None), (OBJ, None)], 9: [("nawfed", None), (OBJ, None)], 10: [("degfed", None), (OBJ, None)], 11: [("unfed", "SM"), (OBJ, None), ("ar ddeg", None)], 12: [("deuddegfed", None), (OBJ, None)], 13: [("trydedd", "SM"), (OBJ, None), ("ar ddeg", None)], 14: [("pedwaredd", "SM"), (OBJ, None), ("ar ddeg", None)], 15: [("pymthegfed", None), (OBJ, None)], 16: [("unfed", None), (OBJ, None), ("ar bymtheg", None)], 17: [("ail", "SM"), (OBJ, None), ("ar bymtheg", None)], 18: [("deunawfed", None), (OBJ, None)], 19: [("pedwaredd", None), (OBJ, None), ("ar bymtheg", None)], } # The script can extrapolate the missing numbers from the base forms. STR_TENS = { 1: [("ugain", None), (OBJ, None)], 2: [("deugain", None), (OBJ, None)], 3: [("trigain", None), (OBJ, None)], 4: [("pedwar ugain", None), (OBJ, None)], } ORD_STR_TENS = { 1: [("ugainfed", None), (OBJ, None)], 2: [("deugainfed", None), (OBJ, None)], 3: [("trigainfed", None), (OBJ, None)], 4: [("pedwar ugainfed", None), (OBJ, None)], } STR_TENS_INFORMAL = { 1: ("undeg", None), 2: ("dauddeg", None), 3: ("trideg", None), 4: ("pedwardeg", None), 5: ("pumdeg", None), 6: ("chwedeg", None), 7: ("saithdeg", None), 8: ("wythdeg", None), 9: ("nawdeg", None), } GENERIC_DOLLARS = ("dolar", "dolarau") GENERIC_CENTS = ("ceiniog", "ceiniogau") CURRENCIES_FEM = ["GBP"] class Num2Word_CY(Num2Word_EU): CURRENCY_FORMS = { # currency code: (sg, pl), (sg, pl) # in Welsh a noun after a numeral is ALWAYS in the singular "EUR": (("euro", "euros"), GENERIC_CENTS), "USD": (GENERIC_DOLLARS, GENERIC_CENTS), "GBP": (("punt", "punnoedd"), ("ceiniog", "ceiniogau")), "CNY": (("yuan", "yuans"), ("ffen", "ffens")), } MINUS_PREFIX_WORD = "meinws " FLOAT_INFIX_WORD = " pwynt " # def setup(self): # Num2Word_EU.setup(self) def __init__(self): pass def float_to_words(self, float_number): # if ordinal: # prefix = self.to_ordinal(int(float_number)) # else: prefix = self.to_cardinal(int(float_number)) float_part = str(float_number).split(".")[1] postfix = " ".join( # Drops the trailing zero and comma [self.to_cardinal(int(c)) for c in float_part] ) return prefix + Num2Word_CY.FLOAT_INFIX_WORD + postfix def hundred_group( self, number, informal=False, gender="masc", ordinal=False ): hundreds = number // 100 until100 = number % 100 # 0 - 99 # list group of number words and mutation info (for the following word) result = ( [] ) if gender == "fem": CW = CARDINAL_WORDS_FEM else: if ordinal: CW = ORDINAL_WORDS else: CW = CARDINAL_WORDS if hundreds > 0: if hundreds > 1: result.extend((CARDINAL_WORDS[hundreds])) result.extend([("cant", None), (OBJ, None)]) if until100: if until100 in [ 1, 8, 11, 16, 20, 21, 31, 36, 41, 48, 61, 68, 71, 81, 88, 91, ]: result.append(("ac", None)) else: result.append(("a", "AM")) if until100: # if informal: # pass if not ordinal and until100 >= 50 and until100 <= 59: units = number % 10 if hundreds > 0: if units == 0: result.append(("hanner", None)) elif units == 1: result.extend([("hanner ac un", None), (OBJ, None)]) else: result.append(("hanner a", "AM")) result.extend(CW[units]) else: if units == 0: result.extend([("hanner cant", None), (OBJ, None)]) elif units == 1: result.extend( [("hanner cant ac un", None), (OBJ, None)] ) else: result.append(("hanner cant a", "AM")) result.extend(CW[units]) else: if (number < 20 and number > 0) or ( number == 0 and hundreds == 0 ): if gender == "fem": result.extend(CARDINAL_WORDS_FEM[int(number)]) else: result.extend(CARDINAL_WORDS[int(number)]) else: tens = until100 // 20 units = number % 20 if ordinal and units == 0: degau = ORD_STR_TENS.get(tens) else: degau = STR_TENS.get(tens) if units != 0: if tens > 1: result.extend(CW[units]) if degau: result.append(("a", "AM")) result.extend(degau) else: result.extend(CW[units]) if degau: result.append(("ar", "SM")) result.extend(degau) elif degau: result.extend(degau) return result def to_ordinal(self, number, informal=False, gender="masc"): if number < 20: return makestring(ORDINAL_WORDS[number]) if number == 100: return "canfed" elif number > 100: raise NotImplementedError("The given number is too large.") return self.to_cardinal( number, informal=False, gender=gender, ordinal=True ) def to_cardinal( self, number, informal=False, gender="masc", ordinal=False, counted=None, raw=False, ): negative = False if number < 0: negative = True number = -1 * number if number == 0: if raw: return CARDINAL_WORDS[0] else: return makestring(CARDINAL_WORDS[0]) elif not number < 999 * 10**33: raise NotImplementedError("The given number is too large.") elif isinstance(number, float): return self.float_to_words(number) # split in groups of 10**3 # groups of three digits starting from right (units (1 - 999), # thousands, millions, ...) groups = ( [] ) lowestgroup = ( None # find the lowest group of 3 digits > 0 for the ordinals ) for pot in [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36]: gr = (number % 10**pot) // 10 ** (pot - 3) groups.append((gr, pot)) if gr and not lowestgroup: lowestgroup = gr # print("groups", groups) result = [] if negative: result.append(("meinws", None)) for gr, pot in reversed(groups): if gr: # print("AAAA", gr, pot, gender) if pot == 6: g = "fem" # mil (1000) is feminine elif pot == 3: g = gender # units depend on the following noun else: g = "masc" # millions etc are masculine # "mil" is feminine if gr > 1 or pot == 3: words = self.hundred_group( gr, informal=informal, gender=g, ordinal=ordinal and (lowestgroup == gr), ) result += words # print(">>>> ", words) if pot > 3: result.append(MILLION_WORDS[pot - 3]) if raw: # need to be able trigger correct mutation on currencies return result else: if number < 100: return makestring(result, counted=counted) else: if counted: result.extend([("o", "SM"), (counted, None)]) return makestring(result) def to_currency( self, val, currency="EUR", cents=True, separator=",", adjective=False ): """ Args: val: Numeric value currency (str): Currency code cents (bool): Verbose cents separator (str): Cent separator adjective (bool): Prefix currency name with adjective Returns: str: Formatted string """ left, right, is_negative = parse_currency_parts(val) 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) cents_str = ( self._cents_verbose(right, currency) if cents else self._cents_terse(right, currency) ) if right == 0: # no pence return "%s%s" % ( minus_str, money_str, # self.pluralize(right, cr2) ) elif left == 0: # no pounds return "%s%s" % ( minus_str, cents_str, # self.pluralize(right, cr2) ) return "%s%s%s %s" % ( minus_str, money_str, # self.pluralize(left, cr1), separator, cents_str, # self.pluralize(right, cr2) ) def _money_verbose(self, number, currency): # used in super().to_currency(), we need to add gender # here for feminine currencies # if currency in CURRENCIES_FEM: # always true in this context if number > 100: m = self.to_cardinal(number, gender="fem", raw=True) # if currency in self.CURRENCY_FORMS: c = self.CURRENCY_FORMS[currency][0][1] m.append(("o", "SM")) m.append((c, None)) # else: # c = currency # m.append((c, None)) return makestring(m) else: # if number > 1: m = self.to_cardinal(number, gender="fem", raw=True) # elif number == 0: # m = self.to_cardinal(number, gender="fem", raw=True) # else: # m = [(OBJ, None)] # if currency in self.CURRENCY_FORMS: c = self.CURRENCY_FORMS[currency][0][0] # else: # c = currency # print("eeeeeeeee", m) # m.append((c, None)) # print("fffffffff", m) return makestring(m, counted=c) # else: # return self.to_cardinal(number, raw=True) def _cents_verbose(self, number, currency): if number == 0: return "" # elif number > 100: # m = self.to_cardinal(number, raw=True) # # if currency in self.CURRENCY_FORMS: # c = self.CURRENCY_FORMS[currency][0][1] # m.append(("o", "SM")) # m.append((c, None)) # # else: # # c = currency # # m.append((c, None)) # return makestring(m) else: if number > 1: m = self.to_cardinal(number, raw=True) else: m = [(OBJ, None)] # if currency in self.CURRENCY_FORMS: c = self.CURRENCY_FORMS[currency][1][0] # else: # c = currency return makestring(m, counted=c) def makestring(result, counted=None): # concatenate numberwords with correct mutation out = [] lastmut = None for w, mut in result: if w == OBJ: if not counted: continue else: w = counted counted = None # only first position if lastmut: out.append(mutate(w, lastmut)) else: out.append(w) lastmut = mut return " ".join(out) def mutate(word, mutation): # print("uuu", word, mutation) if mutation == "SM": return softmutation(word) elif mutation == "AM": return aspiratedmutation(word) # return word # does not occur def softmutation(word): # print("SM<<<<%s>" % word) if word[0] == "p" and word[1] != "h": return "b" + word[1:] elif word[0] == "t" and word[1] != "h": return "d" + word[1:] elif word[0] == "c" and word[1] != "h": return "g" + word[1:] elif word[0] == "b" or word[0] == "m": return "f" + word[1:] elif word[0] == "d" and word[1] != "d": return "d" + word elif word.startswith("ll"): return word[1:] elif word.startswith("rh"): return "r" + word[2:] elif word == "ugain": return "hugain" else: return word def aspiratedmutation(word): if word[0] == "p" and word[1] != "h": return "ph" + word[1:] elif word[0] == "t" and word[1] != "h": return "th" + word[1:] elif word[0] == "c" and word[1] != "h": return "ch" + word[1:] else: return word num2words-0.5.14/num2words/lang_DA.py000066400000000000000000000117631473005321200173450ustar00rootroot00000000000000# -*- 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_EU class Num2Word_DA(lang_EU.Num2Word_EU): GIGA_SUFFIX = "illiarder" MEGA_SUFFIX = "illioner" def setup(self): super(Num2Word_DA, self).setup() self.negword = "minus " self.pointword = "komma" self.exclude_title = ["og", "komma", "minus"] self.mid_numwords = [(1000, "tusind"), (100, "hundrede"), (90, "halvfems"), (80, "firs"), (70, "halvfjerds"), (60, "treds"), (50, "halvtreds"), (40, "fyrre"), (30, "tredive")] self.low_numwords = ["tyve", "nitten", "atten", "sytten", "seksten", "femten", "fjorten", "tretten", "tolv", "elleve", "ti", "ni", "otte", "syv", "seks", "fem", "fire", "tre", "to", "et", "nul"] self.ords = {"nul": "nul", "et": "f\xf8rste", "to": "anden", "tre": "tredje", "fire": "fjerde", "fem": "femte", "seks": "sjette", "syv": "syvende", "otte": "ottende", "ni": "niende", "ti": "tiende", "elleve": "ellevte", "tolv": "tolvte", "tretten": "trett", "fjorten": "fjort", "femten": "femt", "seksten": "sekst", "sytten": "sytt", "atten": "att", "nitten": "nitt", "tyve": "tyv"} self.ordflag = False def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if next[1] == 100 or next[1] == 1000: lst = list(next) lst[0] = 'et' + lst[0] next = tuple(lst) if cnum == 1: if nnum < 10 ** 6 or self.ordflag: return next ctext = "en" if nnum > cnum: if nnum >= 10 ** 6: ctext += " " val = cnum * nnum else: if cnum >= 100 and cnum < 1000: ctext += " og " elif cnum >= 1000 and cnum <= 100000: ctext += "e og " if nnum < 10 < cnum < 100: if nnum == 1: ntext = "en" ntext, ctext = ctext, ntext + "og" elif cnum >= 10 ** 6: ctext += " " val = cnum + nnum word = ctext + ntext return (word, val) def to_ordinal(self, value): self.verify_ordinal(value) self.ordflag = True outword = self.to_cardinal(value) self.ordflag = False for key in self.ords: if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break if value % 100 >= 30 and value % 100 <= 39 or value % 100 == 0: outword += "te" elif value % 100 > 12 or value % 100 == 0: outword += "ende" return outword def to_ordinal_num(self, value): self.verify_ordinal(value) vaerdte = (0, 1, 5, 6, 11, 12) if value % 100 >= 30 and value % 100 <= 39 or value % 100 in vaerdte: return str(value) + "te" elif value % 100 == 2: return str(value) + "en" return str(value) + "ende" def to_currency(self, val, longval=True): if val // 100 == 1 or val == 1: ret = self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re", jointxt="og", longval=longval) return "en " + ret[3:] return self.to_splitnum(val, hightxt="kr", lowtxt="\xf8re", jointxt="og", longval=longval) def to_year(self, val, longval=True): if val == 1: return 'en' if not (val // 100) % 10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt="hundrede", longval=longval) num2words-0.5.14/num2words/lang_DE.py000066400000000000000000000140261473005321200173440ustar00rootroot00000000000000# -*- 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 import re from .lang_EU import Num2Word_EU class Num2Word_DE(Num2Word_EU): CURRENCY_FORMS = { 'EUR': (('Euro', 'Euro'), ('Cent', 'Cent')), 'GBP': (('Pfund', 'Pfund'), ('Penny', 'Pence')), 'USD': (('Dollar', 'Dollar'), ('Cent', 'Cent')), 'CNY': (('Yuan', 'Yuan'), ('Jiao', 'Fen')), 'DEM': (('Mark', 'Mark'), ('Pfennig', 'Pfennig')), } GIGA_SUFFIX = "illiarde" MEGA_SUFFIX = "illion" def setup(self): self.negword = "minus " self.pointword = "Komma" # "Cannot treat float %s as ordinal." self.errmsg_floatord = ( "Die Gleitkommazahl %s kann nicht in eine Ordnungszahl " + "konvertiert werden." ) # "type(((type(%s)) ) not in [long, int, float]" self.errmsg_nonnum = ( "Nur Zahlen (type(%s)) können in Wörter konvertiert werden." ) # "Cannot treat negative num %s as ordinal." self.errmsg_negord = ( "Die negative Zahl %s kann nicht in eine Ordnungszahl " + "konvertiert werden." ) # "abs(%s) must be less than %s." self.errmsg_toobig = "Die Zahl %s muss kleiner als %s sein." self.exclude_title = [] lows = ["Non", "Okt", "Sept", "Sext", "Quint", "Quadr", "Tr", "B", "M"] units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept", "okto", "novem"] tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint", "sexagint", "septuagint", "oktogint", "nonagint"] self.high_numwords = ( ["zent"] + self.gen_high_numwords(units, tens, lows) ) self.mid_numwords = [(1000, "tausend"), (100, "hundert"), (90, "neunzig"), (80, "achtzig"), (70, "siebzig"), (60, "sechzig"), (50, "f\xFCnfzig"), (40, "vierzig"), (30, "drei\xDFig")] self.low_numwords = ["zwanzig", "neunzehn", "achtzehn", "siebzehn", "sechzehn", "f\xFCnfzehn", "vierzehn", "dreizehn", "zw\xF6lf", "elf", "zehn", "neun", "acht", "sieben", "sechs", "f\xFCnf", "vier", "drei", "zwei", "eins", "null"] self.ords = {"eins": "ers", "drei": "drit", "acht": "ach", "sieben": "sieb", "ig": "igs", "ert": "erts", "end": "ends", "ion": "ions", "nen": "ns", "rde": "rds", "rden": "rds"} def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum == 100 or nnum == 1000: return ("ein" + ntext, nnum) elif nnum < 10 ** 6: return next ctext = "eine" if nnum > cnum: if nnum >= 10 ** 6: if cnum > 1: if ntext.endswith("e"): ntext += "n" else: ntext += "en" ctext += " " val = cnum * nnum else: if nnum < 10 < cnum < 100: if nnum == 1: ntext = "ein" ntext, ctext = ctext, ntext + "und" elif cnum >= 10 ** 6: ctext += " " val = cnum + nnum word = ctext + ntext return (word, val) def to_ordinal(self, value): self.verify_ordinal(value) outword = self.to_cardinal(value).lower() for key in self.ords: if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break res = outword + "te" # Exception: "hundertste" is usually preferred over "einhundertste" if res == "eintausendste" or res == "einhundertste": res = res.replace("ein", "", 1) # ... similarly for "millionste" etc. res = re.sub(r'eine ([a-z]+(illion|illiard)ste)$', lambda m: m.group(1), res) # Ordinals involving "Million" etc. are written without a space. # see https://de.wikipedia.org/wiki/Million#Sprachliches res = re.sub(r' ([a-z]+(illion|illiard)ste)$', lambda m: m.group(1), res) return res def to_ordinal_num(self, value): self.verify_ordinal(value) return str(value) + "." def to_currency(self, val, currency='EUR', cents=True, separator=' und', adjective=False): result = super(Num2Word_DE, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) # Handle exception, in german is "ein Euro" and not "eins Euro" return result.replace("eins ", "ein ") def to_year(self, val, longval=True): if not (val // 100) % 10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt="hundert", longval=longval)\ .replace(' ', '') num2words-0.5.14/num2words/lang_EN.py000066400000000000000000000104721473005321200173570ustar00rootroot00000000000000# -*- 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_EU class Num2Word_EN(lang_EU.Num2Word_EU): 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)) num2words-0.5.14/num2words/lang_EN_IN.py000066400000000000000000000021121473005321200177350ustar00rootroot00000000000000# -*- 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" num2words-0.5.14/num2words/lang_EN_NG.py000066400000000000000000000025721473005321200177450ustar00rootroot00000000000000# -*- 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'))} CURRENCY_ADJECTIVES = {'NGN': 'Nigerian'} 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 num2words-0.5.14/num2words/lang_EO.py000066400000000000000000000113431473005321200173560ustar00rootroot00000000000000# -*- 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] num2words-0.5.14/num2words/lang_ES.py000066400000000000000000000463711473005321200173730ustar00rootroot00000000000000# -*- 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 import math from .lang_EU import Num2Word_EU GENERIC_DOLLARS = ('dólar', 'dólares') GENERIC_CENTS = ('centavo', 'centavos') CURRENCIES_UNA = ('SLL', 'SEK', 'NOK', 'CZK', 'DKK', 'ISK', 'SKK', 'GBP', 'CYP', 'EGP', 'FKP', 'GIP', 'LBP', 'SDG', 'SHP', 'SSP', 'SYP', 'INR', 'IDR', 'LKR', 'MUR', 'NPR', 'PKR', 'SCR', 'ESP', 'TRY', 'ITL') CENTS_UNA = ('EGP', 'JOD', 'LBP', 'SDG', 'SSP', 'SYP') class Num2Word_ES(Num2Word_EU): CURRENCY_FORMS = { 'EUR': (('euro', 'euros'), ('céntimo', 'céntimos')), 'ESP': (('peseta', 'pesetas'), ('céntimo', 'céntimos')), 'USD': (GENERIC_DOLLARS, GENERIC_CENTS), 'PEN': (('sol', 'soles'), ('céntimo', 'céntimos')), 'CRC': (('colón', 'colones'), GENERIC_CENTS), 'AUD': (GENERIC_DOLLARS, GENERIC_CENTS), 'CAD': (GENERIC_DOLLARS, GENERIC_CENTS), 'GBP': (('libra', 'libras'), ('penique', 'peniques')), 'RUB': (('rublo', 'rublos'), ('kopeyka', 'kopeykas')), 'SEK': (('corona', 'coronas'), ('öre', 'öre')), 'NOK': (('corona', 'coronas'), ('øre', 'øre')), 'PLN': (('zloty', 'zlotys'), ('grosz', 'groszy')), 'MXN': (('peso', 'pesos'), GENERIC_CENTS), 'RON': (('leu', 'leus'), ('ban', 'bani')), 'INR': (('rupia', 'rupias'), ('paisa', 'paisas')), 'HUF': (('florín', 'florines'), ('fillér', 'fillér')), 'FRF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'CNY': (('yuan', 'yuanes'), ('fen', 'jiaos')), 'CZK': (('corona', 'coronas'), ('haléř', 'haléř')), 'NIO': (('córdoba', 'córdobas'), GENERIC_CENTS), 'VES': (('bolívar', 'bolívares'), ('céntimo', 'céntimos')), 'BRL': (('real', 'reales'), GENERIC_CENTS), 'CHF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'JPY': (('yen', 'yenes'), ('sen', 'sen')), 'KRW': (('won', 'wones'), ('jeon', 'jeon')), 'KPW': (('won', 'wones'), ('chon', 'chon')), 'TRY': (('lira', 'liras'), ('kuruş', 'kuruş')), 'ZAR': (('rand', 'rands'), ('céntimo', 'céntimos')), 'KZT': (('tenge', 'tenges'), ('tïın', 'tïın')), 'UAH': (('hryvnia', 'hryvnias'), ('kopiyka', 'kopiykas')), 'THB': (('baht', 'bahts'), ('satang', 'satang')), 'AED': (('dirham', 'dirhams'), ('fils', 'fils')), 'AFN': (('afghani', 'afghanis'), ('pul', 'puls')), 'ALL': (('lek ', 'leke'), ('qindarkë', 'qindarka')), 'AMD': (('dram', 'drams'), ('luma', 'lumas')), 'ANG': (('florín', 'florines'), GENERIC_CENTS), 'AOA': (('kwanza', 'kwanzas'), ('céntimo', 'céntimos')), 'ARS': (('peso', 'pesos'), GENERIC_CENTS), 'AWG': (('florín', 'florines'), GENERIC_CENTS), 'AZN': (('manat', 'manat'), ('qəpik', 'qəpik')), 'BBD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BDT': (('taka', 'takas'), ('paisa', 'paisas')), 'BGN': (('lev', 'leva'), ('stotinka', 'stotinki')), 'BHD': (('dinar', 'dinares'), ('fils', 'fils')), 'BIF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'BMD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BND': (GENERIC_DOLLARS, GENERIC_CENTS), 'BOB': (('boliviano', 'bolivianos'), GENERIC_CENTS), 'BSD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BTN': (('ngultrum', 'ngultrum'), ('chetrum', 'chetrum')), 'BWP': (('pula', 'pulas'), ('thebe', 'thebes')), 'BYN': (('rublo', 'rublos'), ('kópek', 'kópeks')), 'BYR': (('rublo', 'rublos'), ('kópek', 'kópeks')), 'BZD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'CDF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'CLP': (('peso', 'pesos'), GENERIC_CENTS), 'COP': (('peso', 'pesos'), GENERIC_CENTS), 'CUP': (('peso', 'pesos'), GENERIC_CENTS), 'CVE': (('escudo', 'escudos'), GENERIC_CENTS), 'CYP': (('libra', 'libras'), ('céntimo', 'céntimos')), 'DJF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'DKK': (('corona', 'coronas'), ('øre', 'øre')), 'DOP': (('peso', 'pesos'), GENERIC_CENTS), 'DZD': (('dinar', 'dinares'), ('céntimo', 'céntimos')), 'ECS': (('sucre', 'sucres'), GENERIC_CENTS), 'EGP': (('libra', 'libras'), ('piastra', 'piastras')), 'ERN': (('nakfa', 'nakfas'), ('céntimo', 'céntimos')), 'ETB': (('birr', 'birrs'), ('céntimo', 'céntimos')), 'FJD': (GENERIC_DOLLARS, GENERIC_CENTS), 'FKP': (('libra', 'libras'), ('penique', 'peniques')), 'GEL': (('lari', 'laris'), ('tetri', 'tetris')), 'GHS': (('cedi', 'cedis'), ('pesewa', 'pesewas')), 'GIP': (('libra', 'libras'), ('penique', 'peniques')), 'GMD': (('dalasi', 'dalasis'), ('butut', 'bututs')), 'GNF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'GTQ': (('quetzal', 'quetzales'), GENERIC_CENTS), 'GYD': (GENERIC_DOLLARS, GENERIC_CENTS), 'HKD': (GENERIC_DOLLARS, GENERIC_CENTS), 'HNL': (('lempira', 'lempiras'), GENERIC_CENTS), 'HRK': (('kuna', 'kunas'), ('lipa', 'lipas')), 'HTG': (('gourde', 'gourdes'), ('céntimo', 'céntimos')), 'IDR': (('rupia', 'rupias'), ('céntimo', 'céntimos')), 'ILS': (('séquel', 'séqueles'), ('agora', 'agoras')), 'IQD': (('dinar', 'dinares'), ('fils', 'fils')), 'IRR': (('rial', 'riales'), ('dinar', 'dinares')), 'ISK': (('corona', 'coronas'), ('eyrir', 'aurar')), 'ITL': (('lira', 'liras'), ('céntimo', 'céntimos')), 'JMD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'JOD': (('dinar', 'dinares'), ('piastra', 'piastras')), 'KES': (('chelín', 'chelines'), ('céntimo', 'céntimos')), 'KGS': (('som', 'som'), ('tyiyn', 'tyiyn')), 'KHR': (('riel', 'rieles'), ('céntimo', 'céntimos')), 'KMF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'KWD': (('dinar', 'dinares'), ('fils', 'fils')), 'KYD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'LAK': (('kip', 'kips'), ('att', 'att')), 'LBP': (('libra', 'libras'), ('piastra', 'piastras')), 'LKR': (('rupia', 'rupias'), ('céntimo', 'céntimos')), 'LRD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'LSL': (('loti', 'lotis'), ('céntimo', 'céntimos')), 'LTL': (('lita', 'litas'), ('céntimo', 'céntimos')), 'LVL': (('lat', 'lats'), ('céntimo', 'céntimos')), 'LYD': (('dinar', 'dinares'), ('dírham', 'dírhams')), 'MAD': (('dírham', 'dirhams'), ('céntimo', 'céntimos')), 'MDL': (('leu', 'lei'), ('ban', 'bani')), 'MGA': (('ariary', 'ariaris'), ('iraimbilanja', 'iraimbilanja')), 'MKD': (('denar', 'denares'), ('deni', 'denis')), 'MMK': (('kiat', 'kiats'), ('pya', 'pyas')), 'MNT': (('tugrik', 'tugriks'), ('möngö', 'möngö')), 'MOP': (('pataca', 'patacas'), ('avo', 'avos')), 'MRO': (('ouguiya', 'ouguiyas'), ('khoums', 'khoums')), 'MRU': (('ouguiya', 'ouguiyas'), ('khoums', 'khoums')), 'MUR': (('rupia', 'rupias'), ('céntimo', 'céntimos')), 'MVR': (('rufiyaa', 'rufiyaas'), ('laari', 'laari')), 'MWK': (('kuacha', 'kuachas'), ('tambala', 'tambalas')), 'MYR': (('ringgit', 'ringgit'), ('céntimo', 'céntimos')), 'MZN': (('metical', 'metical'), GENERIC_CENTS), 'NAD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'NGN': (('naira', 'nairas'), ('kobo', 'kobo')), 'NPR': (('rupia', 'rupias'), ('paisa', 'paisas')), 'NZD': (GENERIC_DOLLARS, GENERIC_CENTS), 'OMR': (('rial', 'riales'), ('baisa', 'baisa')), 'PAB': (('balboa', 'balboas'), ('centésimo', 'centésimos')), 'PGK': (('kina', 'kinas'), ('toea', 'toea')), 'PHP': (('peso', 'pesos'), GENERIC_CENTS), 'PKR': (('rupia', 'rupias'), ('paisa', 'paisas')), 'PLZ': (('zloty', 'zlotys'), ('grosz', 'groszy')), 'PYG': (('guaraní', 'guaranís'), ('céntimo', 'céntimos')), 'QAR': (('rial', 'riales'), ('dírham', 'dírhams')), 'QTQ': (('quetzal', 'quetzales'), GENERIC_CENTS), 'RSD': (('dinar', 'dinares'), ('para', 'para')), 'RUR': (('rublo', 'rublos'), ('kopek', 'kopeks')), 'RWF': (('franco', 'francos'), ('céntimo', 'céntimos')), 'SAR': (('riyal', 'riales'), ('halala', 'halalas')), 'SBD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'SCR': (('rupia', 'rupias'), ('céntimo', 'céntimos')), 'SDG': (('libra', 'libras'), ('piastra', 'piastras')), 'SGD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'SHP': (('libra', 'libras'), ('penique', 'peniques')), 'SKK': (('corona', 'coronas'), ('halier', 'haliers')), 'SLL': (('leona', 'leonas'), ('céntimo', 'céntimos')), 'SRD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'SSP': (('libra', 'libras'), ('piastra', 'piastras')), 'STD': (('dobra', 'dobras'), ('céntimo', 'céntimos')), 'SVC': (('colón', 'colones'), GENERIC_CENTS), 'SYP': (('libra', 'libras'), ('piastra', 'piastras')), 'SZL': (('lilangeni', 'emalangeni'), ('céntimo', 'céntimos')), 'TJS': (('somoni', 'somonis'), ('dirame', 'dirames')), 'TMT': (('manat', 'manat'), ('tenge', 'tenge')), 'TND': (('dinar', 'dinares'), ('milésimo', 'milésimos')), 'TOP': (('paanga', 'paangas'), ('céntimo', 'céntimos')), 'TTD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'TWD': (('nuevo dólar', 'nuevos dólares'), ('céntimo', 'céntimos')), 'TZS': (('chelín', 'chelines'), ('céntimo', 'céntimos')), 'UAG': (('hryvnia', 'hryvnias'), ('kopiyka', 'kopiykas')), 'UGX': (('chelín', 'chelines'), ('céntimo', 'céntimos')), 'UYU': (('peso', 'pesos'), ('centésimo', 'centésimos')), 'UZS': (('sum', 'sum'), ('tiyin', 'tiyin')), 'VEF': (('bolívar fuerte', 'bolívares fuertes'), ('céntimo', 'céntimos')), 'VND': (('dong', 'dongs'), ('xu', 'xu')), 'VUV': (('vatu', 'vatu'), ('nenhum', 'nenhum')), 'WST': (('tala', 'tala'), GENERIC_CENTS), 'XAF': (('franco CFA', 'francos CFA'), ('céntimo', 'céntimos')), 'XCD': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'XOF': (('franco CFA', 'francos CFA'), ('céntimo', 'céntimos')), 'XPF': (('franco CFP', 'francos CFP'), ('céntimo', 'céntimos')), 'YER': (('rial', 'riales'), ('fils', 'fils')), 'YUM': (('dinar', 'dinares'), ('para', 'para')), 'ZMW': (('kwacha', 'kwachas'), ('ngwee', 'ngwee')), 'ZRZ': (('zaire', 'zaires'), ('likuta', 'makuta')), 'ZWL': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), 'ZWL': (GENERIC_DOLLARS, ('céntimo', 'céntimos')), } # //CHECK: Is this sufficient?? GIGA_SUFFIX = None MEGA_SUFFIX = "illón" def setup(self): lows = ["cuatr", "tr", "b", "m"] self.high_numwords = self.gen_high_numwords([], [], lows) self.negword = "menos " self.pointword = "punto" self.errmsg_nonnum = "type(%s) no es [long, int, float]" self.errmsg_floatord = "El float %s no puede ser tratado como un" \ " ordinal." self.errmsg_negord = "El número negativo %s no puede ser tratado" \ " como un ordinal." self.errmsg_toobig = ( "abs(%s) deber ser inferior a %s." ) self.gender_stem = "o" self.exclude_title = ["y", "menos", "punto"] self.mid_numwords = [(1000, "mil"), (100, "cien"), (90, "noventa"), (80, "ochenta"), (70, "setenta"), (60, "sesenta"), (50, "cincuenta"), (40, "cuarenta"), (30, "treinta")] self.low_numwords = ["veintinueve", "veintiocho", "veintisiete", "veintiséis", "veinticinco", "veinticuatro", "veintitrés", "veintidós", "veintiuno", "veinte", "diecinueve", "dieciocho", "diecisiete", "dieciséis", "quince", "catorce", "trece", "doce", "once", "diez", "nueve", "ocho", "siete", "seis", "cinco", "cuatro", "tres", "dos", "uno", "cero"] self.ords = {1: "primer", 2: "segund", 3: "tercer", 4: "cuart", 5: "quint", 6: "sext", 7: "séptim", 8: "octav", 9: "noven", 10: "décim", 20: "vigésim", 30: "trigésim", 40: "quadragésim", 50: "quincuagésim", 60: "sexagésim", 70: "septuagésim", 80: "octogésim", 90: "nonagésim", 100: "centésim", 200: "ducentésim", 300: "tricentésim", 400: "cuadrigentésim", 500: "quingentésim", 600: "sexcentésim", 700: "septigentésim", 800: "octigentésim", 900: "noningentésim", 1e3: "milésim", 1e6: "millonésim", 1e9: "billonésim", 1e12: "trillonésim", 1e15: "cuadrillonésim"} def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next ctext = "un" elif cnum == 100 and not nnum % 1000 == 0: ctext += "t" + self.gender_stem if nnum < cnum: if cnum < 100: return "%s y %s" % (ctext, ntext), cnum + nnum return "%s %s" % (ctext, ntext), cnum + nnum elif (not nnum % 1000000) and cnum > 1: ntext = ntext[:-3] + "lones" if nnum == 100: if cnum == 5: ctext = "quinien" ntext = "" elif cnum == 7: ctext = "sete" elif cnum == 9: ctext = "nove" ntext += "t" + self.gender_stem + "s" else: ntext = " " + ntext return (ctext + ntext, cnum * nnum) def to_ordinal(self, value): self.verify_ordinal(value) if value == 0: text = "" elif value <= 10: text = "%s%s" % (self.ords[value], self.gender_stem) elif value <= 12: text = ( "%s%s%s" % (self.ords[10], self.gender_stem, self.to_ordinal(value - 10)) ) elif value <= 100: dec = (value // 10) * 10 text = ( "%s%s %s" % (self.ords[dec], self.gender_stem, self.to_ordinal(value - dec)) ) elif value <= 1e3: cen = (value // 100) * 100 text = ( "%s%s %s" % (self.ords[cen], self.gender_stem, self.to_ordinal(value - cen)) ) elif value < 1e18: # Round down to the nearest 1e(3n) # dec contains the following: # [ 1e3, 1e6): 1e3 # [ 1e6, 1e9): 1e6 # [ 1e9, 1e12): 1e9 # [1e12, 1e15): 1e12 # [1e15, 1e18): 1e15 dec = 1000 ** int(math.log(int(value), 1000)) # Split the parts before and after the word for 'dec' # eg (12, 345) = divmod(12_345, 1_000) high_part, low_part = divmod(value, dec) cardinal = self.to_cardinal(high_part) if high_part != 1 else "" text = ( "%s%s%s %s" % (cardinal, self.ords[dec], self.gender_stem, self.to_ordinal(low_part)) ) else: text = self.to_cardinal(value) return text.strip() def to_ordinal_num(self, value): self.verify_ordinal(value) return "%s%s" % (value, "º" if self.gender_stem == 'o' else "ª") def to_currency(self, val, currency='EUR', cents=True, separator=' con', adjective=False): result = super(Num2Word_ES, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) # Handle exception: In Spanish it's "un euro" and not "uno euro", # except in these currencies, where it's "una": leona, corona, # libra, lira, rupia, lempira, peseta. # The same goes for "veintiuna", "treinta y una"... # Also, this needs to be handled separately for "dollars" and # "cents". # All "cents" are masculine except for: piastra. # Source: https://www.rae.es/dpd/una (section 2.2) # split "dollars" part from "cents" part list_result = result.split(separator + " ") # "DOLLARS" PART (list_result[0]) # Feminine currencies ("una libra", "trescientas libras"...) if currency in CURRENCIES_UNA: # "una libra", "veintiuna libras", "treinta y una libras"... list_result[0] = list_result[0].replace("uno", "una") # "doscientas libras", "trescientas libras"... list_result[0] = list_result[0].replace("cientos", "cientas") # Masc.: Correct orthography for the specific case of "veintiún": list_result[0] = list_result[0].replace("veintiuno", "veintiún") # Masculine currencies: general case ("un euro", "treinta y un # euros"...): list_result[0] = list_result[0].replace("uno", "un") # "CENTS" PART (list_result[1]) # Feminine "cents" ("una piastra", "veintiuna piastras"...) if currency in CENTS_UNA: # "una piastra", "veintiuna piastras", "treinta y una piastras"... list_result[1] = list_result[1].replace("uno", "una") # Masc.: Correct orthography for the specific case of "veintiún": list_result[1] = list_result[1].replace("veintiuno", "veintiún") # Masculine "cents": general case ("un centavo", "treinta y un # centavos"...): list_result[1] = list_result[1].replace("uno", "un") # join back "dollars" part with "cents" part result = (separator + " ").join(list_result) return result num2words-0.5.14/num2words/lang_ES_CO.py000066400000000000000000000024541473005321200177460ustar00rootroot00000000000000# -*- 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_ES import Num2Word_ES class Num2Word_ES_CO(Num2Word_ES): def to_currency(self, val, longval=True, old=False): result = self.to_splitnum(val, hightxt="peso/s", lowtxt="centavo/s", divisor=1, jointxt="y", longval=longval) # Handle exception, in spanish is "un euro" and not "uno euro" return result.replace("uno", "un") num2words-0.5.14/num2words/lang_ES_CR.py000066400000000000000000000025541473005321200177520ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2024, Randall Castro. 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_ES import Num2Word_ES class Num2Word_ES_CR(Num2Word_ES): def to_currency(self, val, longval=True, old=False): result = self.to_splitnum(val, hightxt="colón/es", lowtxt="céntimo/s", divisor=1, jointxt="y", longval=longval) # Handle exception, in spanish is "un euro" and not "uno euro" return result.replace("uno", "un") num2words-0.5.14/num2words/lang_ES_GT.py000066400000000000000000000025761473005321200177640ustar00rootroot00000000000000# -*- 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_ES import Num2Word_ES class Num2Word_ES_GT(Num2Word_ES): def to_currency(self, val, longval=True, old=False): result = self.to_splitnum(val, hightxt="quetzal/es", lowtxt="centavo/s", divisor=1, jointxt="y", longval=longval) # Handle exception, in spanish is "un euro" # and not "uno euro" return result.replace("uno", "un") num2words-0.5.14/num2words/lang_ES_NI.py000066400000000000000000000026071473005321200177530ustar00rootroot00000000000000# -*- 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_ES import Num2Word_ES class Num2Word_ES_NI(Num2Word_ES): CURRENCY_FORMS = { 'NIO': (('córdoba', 'córdobas'), ('centavo', 'centavos')), } def to_currency(self, val, currency='NIO', cents=True, separator=' con', adjective=False): result = super(Num2Word_ES, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) return result.replace("uno", "un") num2words-0.5.14/num2words/lang_ES_VE.py000066400000000000000000000025561473005321200177620ustar00rootroot00000000000000# -*- 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_ES import Num2Word_ES class Num2Word_ES_VE(Num2Word_ES): def to_currency(self, val, longval=True, old=False): hightxt = "bolívar/es" if old else "bolívar/es fuerte/s" result = self.to_splitnum( val, hightxt=hightxt, lowtxt="centavo/s", divisor=1, jointxt="y", longval=longval ) # Handle exception, in spanish is "un euro" and not "uno euro" return result.replace("uno", "un") num2words-0.5.14/num2words/lang_EU.py000066400000000000000000000074341473005321200173720ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base GENERIC_DOLLARS = ('dollar', 'dollars') GENERIC_CENTS = ('cent', 'cents') class Num2Word_EU(Num2Word_Base): CURRENCY_FORMS = { 'AUD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BYN': (('rouble', 'roubles'), ('kopek', 'kopeks')), 'CAD': (GENERIC_DOLLARS, GENERIC_CENTS), # repalced by EUR 'EEK': (('kroon', 'kroons'), ('sent', 'senti')), 'EUR': (('euro', 'euro'), GENERIC_CENTS), 'GBP': (('pound sterling', 'pounds sterling'), ('penny', 'pence')), # replaced by EUR 'LTL': (('litas', 'litas'), GENERIC_CENTS), # replaced by EUR 'LVL': (('lat', 'lats'), ('santim', 'santims')), 'USD': (GENERIC_DOLLARS, GENERIC_CENTS), 'RUB': (('rouble', 'roubles'), ('kopek', 'kopeks')), 'SEK': (('krona', 'kronor'), ('öre', 'öre')), 'NOK': (('krone', 'kroner'), ('øre', 'øre')), 'PLN': (('zloty', 'zlotys', 'zlotu'), ('grosz', 'groszy')), 'MXN': (('peso', 'pesos'), GENERIC_CENTS), 'RON': (('leu', 'lei', 'de lei'), ('ban', 'bani', 'de bani')), 'INR': (('rupee', 'rupees'), ('paisa', 'paise')), 'HUF': (('forint', 'forint'), ('fillér', 'fillér')), 'ISK': (('króna', 'krónur'), ('aur', 'aurar')), 'UZS': (('sum', 'sums'), ('tiyin', 'tiyins')), 'SAR': (('saudi riyal', 'saudi riyals'), ('halalah', 'halalas')) } CURRENCY_ADJECTIVES = { 'AUD': 'Australian', 'BYN': 'Belarusian', 'CAD': 'Canadian', 'EEK': 'Estonian', 'USD': 'US', 'RUB': 'Russian', 'NOK': 'Norwegian', 'MXN': 'Mexican', 'RON': 'Romanian', 'INR': 'Indian', 'HUF': 'Hungarian', 'ISK': 'íslenskar', 'UZS': 'Uzbekistan', 'SAR': 'Saudi' } GIGA_SUFFIX = "illiard" MEGA_SUFFIX = "illion" 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 pluralize(self, n, forms): form = 0 if n == 1 else 1 return forms[form] def setup(self): lows = ["non", "oct", "sept", "sext", "quint", "quadr", "tr", "b", "m"] units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept", "octo", "novem"] tens = ["dec", "vigint", "trigint", "quadragint", "quinquagint", "sexagint", "septuagint", "octogint", "nonagint"] self.high_numwords = ["cent"] + self.gen_high_numwords(units, tens, lows) num2words-0.5.14/num2words/lang_FA.py000066400000000000000000000114201473005321200173350ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2018, Abdullah Alhazmy, Alhazmy13. All Rights Reserved. # Copyright (c) 2020, Hamidreza Kalbasi. All Rights Reserved. # Copyright (c) 2023, Nika Soltani Tehrani. 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 decimal import Decimal from math import floor farsiOnes = [ "", "یک", "دو", "سه", "چهار", "پنج", "شش", "هفت", "هشت", "نه", "ده", "یازده", "دوازده", "سیزده", "چهارده", "پانزده", "شانزده", "هفده", "هجده", "نوزده", ] farsiTens = [ "", "ده", "بیست", "سی", "چهل", "پنجاه", "شصت", "هفتاد", "هشتاد", "نود", ] farsiHundreds = [ "", "صد", "دویست", "سیصد", "چهارصد", "پانصد", "ششصد", "هفتصد", "هشتصد", "نهصد", ] farsiBig = [ '', ' هزار', ' میلیون', " میلیارد", ' تریلیون', " تریلیارد", ] farsiFrac = ["", "دهم", "صدم"] farsiFracBig = ["", "هزارم", "میلیونیم", "میلیاردیم"] farsiSeperator = ' و ' class Num2Word_FA(object): # Those are unused errmsg_toobig = "Too large" MAXNUM = 10 ** 36 def __init__(self): self.number = 0 def float2tuple(self, value): pre = int(value) # Simple way of finding decimal places to update the precision self.precision = abs(Decimal(str(value)).as_tuple().exponent) post = abs(value - pre) * 10**self.precision if abs(round(post) - post) < 0.01: # We generally floor all values beyond our precision (rather than # rounding), but in cases where we have something like 1.239999999, # which is probably due to python's handling of floats, we actually # want to consider it as 1.24 instead of 1.23 post = int(round(post)) else: post = int(floor(post)) return pre, post, self.precision def cardinal3(self, number): if number <= 19: return farsiOnes[number] if number < 100: x, y = divmod(number, 10) if y == 0: return farsiTens[x] return farsiTens[x] + farsiSeperator + farsiOnes[y] x, y = divmod(number, 100) if y == 0: return farsiHundreds[x] return farsiHundreds[x] + farsiSeperator + self.cardinal3(y) def cardinalPos(self, number): x = number res = '' for b in farsiBig: x, y = divmod(x, 1000) if y == 0: continue yx = self.cardinal3(y) + b if b == ' هزار' and y == 1: yx = 'هزار' if res == '': res = yx else: res = yx + farsiSeperator + res return res def fractional(self, number, level): if number == 5: return "نیم" x = self.cardinalPos(number) ld3, lm3 = divmod(level, 3) ltext = (farsiFrac[lm3] + " " + farsiFracBig[ld3]).strip() return x + " " + ltext def to_currency(self, value): return self.to_cardinal(value) + " تومان" def to_ordinal(self, number): r = self.to_cardinal(number) if r[-1] == 'ه' and r[-2] == 'س': return r[:-1] + 'وم' return r + 'م' def to_year(self, value): return self.to_cardinal(value) @staticmethod def to_ordinal_num(value): return str(value)+"م" def to_cardinal(self, number): if number < 0: return "منفی " + self.to_cardinal(-number) if number == 0: return "صفر" x, y, level = self.float2tuple(number) if y == 0: return self.cardinalPos(x) if x == 0: return self.fractional(y, level) return self.cardinalPos(x) + farsiSeperator + self.fractional(y, level) num2words-0.5.14/num2words/lang_FI.py000066400000000000000000000564571473005321200173700ustar00rootroot00000000000000# -*- 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 collections import OrderedDict from . import lang_EU GENERIC_CENTS = ('sentti', 'senttiä') GENERIC_CENTAVOS = ('centavo', 'centavoa') # grammatical cases NOM = 10 # nominative: the dictionary form GEN = 11 # genitive: ~of/'s ACC = 12 # accusative: not used; either nominative or genitive PTV = 13 # partitive: as an object # locative cases (internal) INE = 14 # inessive: in ELA = 15 # elative: from/out of ILL = 16 # illative: into # locative cases (external) ADE = 17 # adessive: at/on ABL = 18 # ablative: from (after being at/on, not in) ALL = 19 # allative: to # essive ESS = 20 # essive: as (in the role of) TRANSL = 21 # translative: to (the role of; being sth) # rare INSTRUC = 22 # instructive: with (plural is the same as singular) ABE = 23 # abessive: without COM = 24 # comitative: together with (plural = singular) NAME_TO_CASE = { 'nominative': NOM, 'genitive': GEN, 'accusative': ACC, 'partitive': PTV, 'inessive': INE, 'elative': ELA, 'illative': ILL, 'adessive': ADE, 'ablative': ABL, 'allative': ALL, 'essive': ESS, 'translative': TRANSL, 'instructive': INSTRUC, 'abessive': ABE, 'comitative': COM, } # https://en.wikibooks.org/wiki/Finnish/Grammar-Vowel_harmony BACK_TO_FRONT = { 'a': 'ä', 'o': 'ö', 'u': 'y', } # https://en.wiktionary.org/wiki/Appendix:Finnish_nominal_inflection # CASE: (SINGULAR_SUFFIX+, PLURAL_SUFFIX+) KOTUS_TYPE = { # Kotus type 5/risti, no gradation 5: { # grammatical NOM: ('i', 'it'), GEN: ('in', 'ien'), PTV: ('ia', 'eja'), # locative, internal INE: ('issa', 'eissa'), ELA: ('ista', 'eista'), ILL: ('iin', 'eihin'), # locative, external ADE: ('illa', 'eilla'), ABL: ('ilta', 'eilta'), ALL: ('ille', 'eille'), # essive ESS: ('ina', 'eina'), TRANSL: ('iksi', 'eiksi'), # rare INSTRUC: ('ein', 'ein'), ABE: ('itta', 'eitta'), COM: ('eine', 'eine'), # works better }, # Kotus type 7/ovi, no gradation 7: { # grammatical NOM: ('i', 'et'), GEN: ('en', 'ien'), PTV: ('ea', 'ia'), # locative, internal INE: ('essa', 'issa'), ELA: ('esta', 'ista'), ILL: ('een', 'iin'), # locative, external ADE: ('ella', 'illa'), ABL: ('elta', 'ilta'), ALL: ('elle', 'ille'), # essive ESS: ('ena', 'ina'), TRANSL: ('eksi', 'iksi'), # rare INSTRUC: ('in', 'in'), ABE: ('etta', 'itta'), COM: ('ine', 'ine'), # works better }, # Kotus type 8/nalle, no gradation 8: { # grammatical NOM: ('e', 'et'), GEN: ('en', ('ejen', 'ein')), PTV: ('ea', 'eja'), # locative, internal INE: ('essa', 'eissa'), ELA: ('esta', 'eista'), ILL: ('een', 'eihin'), # locative, external ADE: ('ella', 'eilla'), ABL: ('elta', 'eilta'), ALL: ('elle', 'eille'), # essive ESS: ('ena', 'eina'), TRANSL: ('eksi', 'eiksi'), # rare INSTRUC: ('ein', 'ein'), ABE: ('etta', 'eitta'), COM: ('eine', 'eine'), # works better }, # Kotus type 9/kala, t-d gradation (sata) 109: { # grammatical NOM: ('ta', 'dat'), GEN: ('dan', ('tojen', 'tain')), PTV: ('taa', 'toja'), # locative, internal INE: ('dassa', 'doissa'), ELA: ('dasta', 'doista'), ILL: ('taan', 'toihin'), # locative, external ADE: ('dalla', 'doilla'), ABL: ('dalta', 'doilta'), ALL: ('dalle', 'doille'), # essive ESS: ('tana', 'toina'), TRANSL: ('daksi', 'doiksi'), # rare INSTRUC: ('doin', 'doin'), ABE: ('datta', 'doitta'), COM: ('toine', 'toine'), # works better }, # Kotus type 10/koira, no gradation 10: { # grammatical NOM: ('a', 'at'), GEN: ('an', ('ien', 'ain')), PTV: ('aa', 'ia'), # locative, internal INE: ('assa', 'issa'), ELA: ('asta', 'ista'), ILL: ('aan', 'iin'), # locative, external ADE: ('alla', 'illa'), ABL: ('alta', 'ilta'), ALL: ('alle', 'ille'), # essive ESS: ('ana', 'ina'), TRANSL: ('aksi', 'iksi'), # rare INSTRUC: ('in', 'in'), ABE: ('atta', 'itta'), COM: ('ine', 'ine'), # works better }, # Kotus type 27/käsi, t-d gradation 27: { # grammatical NOM: ('si', 'det'), GEN: ('den', ('sien', 'tten')), PTV: ('tta', 'sia'), # locative, internal INE: ('dessa', 'sissa'), ELA: ('desta', 'sista'), ILL: ('teen', 'siin'), # locative, external ADE: ('della', 'silla'), ABL: ('delta', 'silta'), ALL: ('delle', 'sille'), # essive ESS: ('tena', 'sina'), TRANSL: ('deksi', 'siksi'), # rare INSTRUC: ('sin', 'sin'), ABE: ('detta', 'sitta'), COM: ('sine', 'sine'), # works better }, # Kotus type 31/kaksi, t-d gradation 31: { # grammatical NOM: ('ksi', 'hdet'), GEN: ('hden', 'ksien'), PTV: ('hta', 'ksia'), # locative, internal INE: ('hdessa', 'ksissa'), ELA: ('hdesta', 'ksista'), ILL: ('hteen', 'ksiin'), # locative, external ADE: ('hdella', 'ksilla'), ABL: ('hdelta', 'ksilta'), ALL: ('hdelle', 'ksille'), # essive ESS: ('htena', 'ksina'), TRANSL: ('hdeksi', 'ksiksi'), # rare INSTRUC: ('ksin', 'ksin'), ABE: ('hdetta', 'ksitta'), COM: ('ksine', 'ksine'), # works better }, # Kotus type 32/sisar, no gradation 32: { # grammatical NOM: ('', 'et'), GEN: ('en', ('ien', 'ten')), PTV: ('ta', 'ia'), # locative, internal INE: ('essa', 'issa'), ELA: ('esta', 'ista'), ILL: ('een', 'iin'), # locative, external ADE: ('ella', 'illa'), ABL: ('elta', 'ilta'), ALL: ('elle', 'ille'), # essive ESS: ('ena', 'ina'), TRANSL: ('eksi', 'iksi'), # rare INSTRUC: ('in', 'in'), ABE: ('etta', 'itta'), COM: ('ine', 'ine'), # works better }, # Kotus type 38/nainen, no gradation 38: { # grammatical NOM: ('nen', 'set'), GEN: ('sen', ('sten', 'sien')), PTV: ('sta', 'sia'), # locative, internal INE: ('sessa', 'sissa'), ELA: ('sesta', 'sista'), ILL: ('seen', 'siin'), # locative, external ADE: ('sella', 'silla'), ABL: ('selta', 'silta'), ALL: ('selle', 'sille'), # essive ESS: ('sena', 'sina'), TRANSL: ('seksi', 'siksi'), # rare INSTRUC: ('sin', 'sin'), ABE: ('setta', 'sitta'), COM: ('sine', 'sine'), # works better }, # Kotus type 45/kahdeksas, nt-nn gradation 45: { # grammatical NOM: ('s', 'nnet'), GEN: ('nnen', 'nsien'), PTV: ('tta', 'nsia'), # locative, internal INE: ('nnessa', 'nsissa'), ELA: ('nnesta', 'nsista'), ILL: ('nteen', 'nsiin'), # locative, external ADE: ('nnella', 'nsilla'), ABL: ('nnelta', 'nsilta'), ALL: ('nnelle', 'nsille'), # essive ESS: ('ntena', 'nsina'), TRANSL: ('nneksi', 'nsiksi'), # rare INSTRUC: ('nsin', 'nsin'), ABE: ('nnetta', 'nsitta'), COM: ('nsine', 'nsine'), # works better }, # Kotus type 46/tuhat, nt-nn gradation 46: { # grammatical NOM: ('t', 'nnet'), GEN: ('nnen', ('nsien', 'nten')), PTV: ('tta', 'nsia'), # locative, internal INE: ('nnessa', 'nsissa'), ELA: ('nnesta', 'nsista'), ILL: ('nteen', 'nsiin'), # locative, external ADE: ('nnella', 'nsilla'), ABL: ('nnelta', 'nsilta'), ALL: ('nnelle', 'nsille'), # essive ESS: ('ntena', 'nsina'), TRANSL: ('nneksi', 'nsiksi'), # rare INSTRUC: ('nsin', 'nsin'), ABE: ('nnetta', 'nsitta'), COM: ('nsine', 'nsine'), # works better }, } # kolme KOTUS_TYPE[108] = { c: (KOTUS_TYPE[8][c][0], KOTUS_TYPE[7][c][1]) for c in KOTUS_TYPE[8] } KOTUS_TYPE[108][INSTRUC] = ('en', 'in') KOTUS_TYPE[108][ABE] = ('etta', 'itta') KOTUS_TYPE[108][COM] = ('ine', 'ine') # seitsemän, kahdeksan, yhdeksän KOTUS_TYPE[110] = KOTUS_TYPE[10].copy() KOTUS_TYPE[110][NOM] = ('an', 'at') # kymmenen KOTUS_TYPE[132] = KOTUS_TYPE[32].copy() KOTUS_TYPE[132][NOM] = ('en', 'et') def inflect(parts, options): if not isinstance(parts, list): parts = [parts] out = '' for part in parts: # part is plain text, concat and continue if not isinstance(part, tuple): out += part continue # predefined case (kaksikymmentä, ...) tmp_case = options.case if len(part) == 3: # override singular nominative only if options.case == NOM and not options.plural: tmp_case = part[2] part = part[:2] # stem and suffix stem, kotus_type = part suffix = KOTUS_TYPE[kotus_type][tmp_case][options.plural] # many choices, choose preferred or first if isinstance(suffix, tuple): common = set(suffix) & set(options.prefer or set()) if len(common) == 1: suffix = common.pop() else: suffix = suffix[0] # apply vowel harmony if not set(BACK_TO_FRONT) & set(stem): for back, front in BACK_TO_FRONT.items(): suffix = suffix.replace(back, front) # concat out += stem + suffix return out class Options(object): def __init__(self, ordinal, case, plural, prefer): self.ordinal = ordinal self.case = case self.plural = plural self.prefer = prefer def variation(self, ordinal=None, case=None, plural=None, prefer=None): return Options( ordinal if ordinal is not None else self.ordinal, case if case is not None else self.case, plural if plural is not None else self.plural, prefer if prefer is not None else self.prefer, ) class Num2Word_FI(lang_EU.Num2Word_EU): CURRENCY_FORMS = { 'BRL': (('real', 'realia'), GENERIC_CENTAVOS), 'CHF': (('frangi', 'frangia'), ('rappen', 'rappenia')), 'CNY': (('juan', 'juania'), ('fen', 'feniä')), 'EUR': (('euro', 'euroa'), GENERIC_CENTS), 'FIM': (('markka', 'markkaa'), ('penni', 'penniä')), # historical 'INR': (('rupia', 'rupiaa'), ('paisa', 'paisaa')), 'JPY': (('jeni', 'jeniä'), ('sen', 'seniä')), # rare subunit 'KRW': (('won', 'wonia'), ('jeon', 'jeonia')), # rare subunit 'KPW': (('won', 'wonia'), ('chon', 'chonia')), # rare subunit 'MXN': (('peso', 'pesoa'), GENERIC_CENTAVOS), 'RUB': (('rupla', 'ruplaa'), ('kopeekka', 'kopeekkaa')), 'TRY': (('liira', 'liiraa'), ('kuruş', 'kuruşia')), 'ZAR': (('randi', 'randia'), GENERIC_CENTS), } # crowns for curr_code in 'DKK', 'ISK', 'NOK', 'SEK': CURRENCY_FORMS[curr_code] = (('kruunu', 'kruunua'), ('äyri', 'äyriä')) # dollars for curr_code in 'AUD', 'CAD', 'HKD', 'NZD', 'SGD', 'USD': CURRENCY_FORMS[curr_code] = ( ('dollari', 'dollaria'), GENERIC_CENTS) # pounds for curr_code in ('GBP',): CURRENCY_FORMS[curr_code] = (('punta', 'puntaa'), ('penny', 'pennyä')) CURRENCY_ADJECTIVES = { 'AUD': 'Australian', 'BRL': 'Brasilian', 'CAD': 'Kanadan', 'CHF': 'Sveitsin', 'DKK': 'Tanskan', 'FIM': 'Suomen', # historical 'GBP': 'Englannin', 'HKD': 'Hongkongin', 'INR': 'Intian', 'ISK': 'Islannin', 'KRW': 'Etelä-Korean', 'KPW': 'Pohjois-Korean', 'MXN': 'Meksikon', 'NOK': 'Norjan', 'NZD': 'Uuden-Seelannin', 'RUB': 'Venäjän', 'SEK': 'Ruotsin', 'SGD': 'Singaporen', 'TRY': 'Turkin', 'USD': 'Yhdysvaltain', 'ZAR': 'Etelä-Afrikan', } def __init__(self): self.ords = OrderedDict() super(Num2Word_FI, self).__init__() def set_numwords(self): self.set_high_numwords(self.high_numwords) self.set_mid_numwords(self.mid_numwords, self.mid_ords) self.set_low_numwords(self.low_numwords, self.low_ords) def set_high_numwords(self, high): # references: # https://fi.wikipedia.org/wiki/Suurten_lukujen_nimet # https://en.wikipedia.org/wiki/Names_of_large_numbers#Standard_dictionary_numbers # translate to Finnish replacements = [ ("qu", "kv"), ("x", "ks"), ("c", "k"), ("kent", "sent"), # applied after c -> k to cent ] translated = [] for i, numword in enumerate(high): # notes: # - 1e6**9 can be either noviljoona or noniljoona # - 1e6**38 and above are untested # 1e6**6 is sekstiljoona but 1e6**16 is sedekiljoona if numword.startswith("sex") and numword != "sext": numword = numword.replace("sex", "se") # 1e6**7 is septiljoona but 1e6**17 is septendekiljoona elif numword.startswith("sept") and numword != "sept": numword = "septen" + numword[len("sept"):] # 1e6**8 is oktiljoona but 1e6**18 is duodevigintiljoona # (2 from 20) elif numword.startswith("octo"): numword = high[i + -10] numword = "duode" + numword[len("octo"):] # 1e6**9 is noniljoona but 1e6**19 is undevigintiljoona (1 from 20) elif numword.startswith("nove"): numword = high[i + -10] numword = "unde" + numword[len("nove") + 1:] # apply general replacements to all numwords for repl in replacements: numword = numword.replace(repl[0], repl[1]) translated.append(numword) max = 6 * len(translated) for word, n in zip(translated, range(max, 0, -6)): if n == 6: # irregularity considering short scale and long scale self.cards[10 ** 9] = ("miljard", 5) self.ords[10 ** 9] = ("miljardi", 45) self.cards[10 ** n] = (word + "iljoon", 10) self.ords[10 ** n] = (word + "iljoona", 45) def set_mid_numwords(self, cards, ords): for key, val in cards: self.cards[key] = val for key, val in ords: self.ords[key] = val def set_low_numwords(self, cards, ords): for key, val in cards: self.cards[key] = val for key, val in ords: self.ords[key] = val def setup(self): super(Num2Word_FI, self).setup() self.negword = "miinus " self.pointword = "pilkku" self.exclude_title = ["pilkku", "miinus"] self.mid_numwords = [ (1000, ("tuha", 46)), (100, ("sa", 109)), (90, [("yhdeks", 110), ("kymmen", 132, PTV)]), (80, [("kahdeks", 110), ("kymmen", 132, PTV)]), (70, [("seitsem", 110), ("kymmen", 132, PTV)]), (60, [("kuu", 27), ("kymmen", 132, PTV)]), (50, [("vii", 27), ("kymmen", 132, PTV)]), (40, [("nelj", 10), ("kymmen", 132, PTV)]), (30, [("kolm", 108), ("kymmen", 132, PTV)]), ] self.mid_ords = [ (1000, ("tuhanne", 45)), (100, ("sada", 45)), (90, [("yhdeksä", 45), ("kymmene", 45)]), (80, [("kahdeksa", 45), ("kymmene", 45)]), (70, [("seitsemä", 45), ("kymmene", 45)]), (60, [("kuude", 45), ("kymmene", 45)]), (50, [("viide", 45), ("kymmene", 45)]), (40, [("neljä", 45), ("kymmene", 45)]), (30, [("kolma", 45), ("kymmene", 45)]), ] self.low_numwords = [ (20, [("ka", 31), ("kymmen", 132, PTV)]), (19, [("yhdeks", 110), "toista"]), (18, [("kahdeks", 110), "toista"]), (17, [("seitsem", 110), "toista"]), (16, [("kuu", 27), "toista"]), (15, [("vii", 27), "toista"]), (14, [("nelj", 10), "toista"]), (13, [("kolm", 108), "toista"]), (12, [("ka", 31), "toista"]), (11, [("y", 31), "toista"]), (10, ("kymmen", 132)), (9, ("yhdeks", 110)), (8, ("kahdeks", 110)), (7, ("seitsem", 110)), (6, ("kuu", 27)), (5, ("vii", 27)), (4, ("nelj", 10)), (3, ("kolm", 108)), (2, ("ka", 31)), (1, ("y", 31)), (0, ("noll", 10)), ] self.low_ords = [ (20, [("kahde", 45), ("kymmene", 45)]), (19, [("yhdeksä", 45), "toista"]), (18, [("kahdeksa", 45), "toista"]), (17, [("seitsemä", 45), "toista"]), (16, [("kuude", 45), "toista"]), (15, [("viide", 45), "toista"]), (14, [("neljä", 45), "toista"]), (13, [("kolma", 45), "toista"]), (12, [("kahde", 45), "toista"]), (11, [("yhde", 45), "toista"]), (10, ("kymmene", 45)), (9, ("yhdeksä", 45)), (8, ("kahdeksa", 45)), (7, ("seitsemä", 45)), (6, ("kuude", 45)), (5, ("viide", 45)), (4, ("neljä", 45)), (3, ("kolma", 45)), (2, ("toi", 38)), (1, ("ensimmäi", 38)), (0, ("nolla", 45)), ] def merge(self, lpair, rpair, options): ltext, lnum = lpair rtext, rnum = rpair # http://www.kielitoimistonohjepankki.fi/ohje/49 fmt = "%s%s" # ignore lpair if lnum is 1 if lnum == 1: rtext = inflect(rtext, options) return (rtext, rnum) # rnum is added to lnum elif lnum > rnum: ltext = inflect(ltext, options) rtext = inflect(rtext, options) # separate groups with space if lnum >= 1000: fmt = "%s %s" return (fmt % (ltext, rtext), lnum + rnum) # rnum is multiplied by lnum elif lnum < rnum: if options.ordinal: # kahdessadas, not toinensadas if lnum == 2: ltext = ("kahde", 45) rtext = inflect(rtext, options) else: # kaksituhatta but kahdettuhannet rcase = options.case if options.case == NOM and not options.plural: rcase = PTV rtext = inflect(rtext, options.variation(case=rcase)) ltext = inflect(ltext, options) return (fmt % (ltext, rtext), lnum * rnum) def to_cardinal(self, value, case='nominative', plural=False, prefer=None): case = NAME_TO_CASE[case] options = Options(False, case, plural, prefer) try: assert int(value) == value except (ValueError, TypeError, AssertionError): if case != NOM: raise NotImplementedError( "Cases other than nominative are not implemented for " "cardinal floating point numbers.") return self.to_cardinal_float(value) out = "" if value < 0: value = abs(value) out = self.negword if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) val = self.splitnum(value, options) words, num = self.clean(val, options) return self.title(out + words) def to_ordinal(self, value, case='nominative', plural=False, prefer=None): case = NAME_TO_CASE[case] options = Options(True, case, plural, prefer) self.verify_ordinal(value) if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) val = self.splitnum(value, options) words, num = self.clean(val, options) return self.title(words) def to_ordinal_num(self, value, case='nominative', plural=False): case = NAME_TO_CASE[case] raise NotImplementedError def to_year(self, val, suffix=None, longval=True): suffix = suffix or "" if val < 0: val = abs(val) suffix = suffix or " ennen ajanlaskun alkua" return self.to_cardinal(val).replace(" ", "") + suffix def to_currency(self, val, currency="EUR", cents=True, separator=" ja", adjective=False): return super(Num2Word_FI, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) def splitnum(self, value, options): elems = self.ords if options.ordinal else self.cards for elem in elems: if elem > value: continue out = [] if value == 0: div, mod = 1, 0 else: div, mod = divmod(value, elem) if div == 1: out.append((elems[1], 1)) else: if div == value: # The system tallies, eg Roman Numerals return [(div * elems[elem], div*elem)] out.append(self.splitnum(div, options)) out.append((elems[elem], elem)) if mod: out.append(self.splitnum(mod, options)) return out def clean(self, val, options): out = val while len(val) != 1: out = [] left, right = val[:2] if isinstance(left, tuple) and isinstance(right, tuple): out.append(self.merge(left, right, options)) if val[2:]: out.append(val[2:]) else: for elem in val: if isinstance(elem, list): if len(elem) == 1: out.append(elem[0]) else: out.append(self.clean(elem, options)) else: out.append(elem) val = out return out[0] num2words-0.5.14/num2words/lang_FR.py000066400000000000000000000102411473005321200173560ustar00rootroot00000000000000# -*- 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_EU import Num2Word_EU class Num2Word_FR(Num2Word_EU): CURRENCY_FORMS = { 'EUR': (('euro', 'euros'), ('centime', 'centimes')), 'USD': (('dollar', 'dollars'), ('cent', 'cents')), 'FRF': (('franc', 'francs'), ('centime', 'centimes')), 'GBP': (('livre', 'livres'), ('penny', 'pence')), 'CNY': (('yuan', 'yuans'), ('fen', 'jiaos')), } def setup(self): Num2Word_EU.setup(self) self.negword = "moins " self.pointword = "virgule" self.errmsg_nonnum = ( u"Seulement des nombres peuvent être convertis en mots." ) self.errmsg_toobig = ( u"Nombre trop grand pour être converti en mots (abs(%s) > %s)." ) self.exclude_title = ["et", "virgule", "moins"] self.mid_numwords = [(1000, "mille"), (100, "cent"), (80, "quatre-vingts"), (60, "soixante"), (50, "cinquante"), (40, "quarante"), (30, "trente")] self.low_numwords = ["vingt", "dix-neuf", "dix-huit", "dix-sept", "seize", "quinze", "quatorze", "treize", "douze", "onze", "dix", "neuf", "huit", "sept", "six", "cinq", "quatre", "trois", "deux", "un", "zéro"] self.ords = { "cinq": "cinquième", "neuf": "neuvième", } def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next else: if (not (cnum - 80) % 100 or (not cnum % 100 and cnum < 1000))\ and nnum < 1000000 \ and ctext[-1] == "s": ctext = ctext[:-1] if cnum < 1000 and nnum != 1000 and \ ntext[-1] != "s" and not nnum % 100: ntext += "s" if nnum < cnum < 100: if nnum % 10 == 1 and cnum != 80: return ("%s et %s" % (ctext, ntext), cnum + nnum) return ("%s-%s" % (ctext, ntext), cnum + nnum) if nnum > cnum: return ("%s %s" % (ctext, ntext), cnum * nnum) return ("%s %s" % (ctext, ntext), cnum + nnum) # Is this right for such things as 1001 - "mille unième" instead of # "mille premier"?? "millième"?? def to_ordinal(self, value): self.verify_ordinal(value) if value == 1: return "premier" word = self.to_cardinal(value) for src, repl in self.ords.items(): if word.endswith(src): word = word[:-len(src)] + repl break else: if word[-1] == "e": word = word[:-1] word = word + "ième" return word def to_ordinal_num(self, value): self.verify_ordinal(value) out = str(value) out += "er" if value == 1 else "me" return out def to_currency(self, val, currency='EUR', cents=True, separator=' et', adjective=False): result = super(Num2Word_FR, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) return result num2words-0.5.14/num2words/lang_FR_BE.py000066400000000000000000000036261473005321200177350ustar00rootroot00000000000000# -*- 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_FR import Num2Word_FR class Num2Word_FR_BE(Num2Word_FR): def setup(self): Num2Word_FR.setup(self) self.mid_numwords = [(1000, "mille"), (100, "cent"), (90, "nonante"), (80, "quatre-vingt"), (70, "septante"), (60, "soixante"), (50, "cinquante"), (40, "quarante"), (30, "trente")] def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next if cnum < 1000 and nnum != 1000 and\ ntext[-1] != "s" and not nnum % 100: ntext += "s" if nnum < cnum < 100: if nnum % 10 == 1: return ("%s et %s" % (ctext, ntext), cnum + nnum) return ("%s-%s" % (ctext, ntext), cnum + nnum) if nnum > cnum: return ("%s %s" % (ctext, ntext), cnum * nnum) return ("%s %s" % (ctext, ntext), cnum + nnum) num2words-0.5.14/num2words/lang_FR_CH.py000066400000000000000000000036211473005321200177340ustar00rootroot00000000000000# -*- 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_FR import Num2Word_FR class Num2Word_FR_CH(Num2Word_FR): def setup(self): Num2Word_FR.setup(self) self.mid_numwords = [(1000, "mille"), (100, "cent"), (90, "nonante"), (80, "huitante"), (70, "septante"), (60, "soixante"), (50, "cinquante"), (40, "quarante"), (30, "trente")] def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next if cnum < 1000 and nnum != 1000 and\ ntext[-1] != "s" and not nnum % 100: ntext += "s" if nnum < cnum < 100: if nnum % 10 == 1: return ("%s et %s" % (ctext, ntext), cnum + nnum) return ("%s-%s" % (ctext, ntext), cnum + nnum) if nnum > cnum: return ("%s %s" % (ctext, ntext), cnum * nnum) return ("%s %s" % (ctext, ntext), cnum + nnum) num2words-0.5.14/num2words/lang_FR_DZ.py000066400000000000000000000025351473005321200177620ustar00rootroot00000000000000# -*- 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_FR import Num2Word_FR class Num2Word_FR_DZ(Num2Word_FR): CURRENCY_FORMS = { 'DIN': (('dinard', 'dinards'), ('centime', 'centimes')), } def to_currency(self, val, currency='DIN', cents=True, separator=' et', adjective=False): result = super(Num2Word_FR, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) return result num2words-0.5.14/num2words/lang_HE.py000066400000000000000000000264771473005321200173650ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .compat import to_s from .currency import parse_currency_parts from .utils import get_digits, splitbyx ZERO = (u'אפס',) ONES = { 1: (u'אחת', u'אחד', u'אחת', u'אחד', u'ראשונה', u'ראשון', u'ראשונות', u'ראשונים'), 2: (u'שתיים', u'שניים', u'שתי', u'שני', u'שנייה', u'שני', u'שניות', u'שניים'), 3: (u'שלוש', u'שלושה', u'שלוש', u'שלושת', u'שלישית', u'שלישי', u'שלישיות', u'שלישיים'), 4: (u'ארבע', u'ארבעה', u'ארבע', u'ארבעת', u'רביעית', u'רביעי', u'רביעיות', u'רביעיים'), 5: (u'חמש', u'חמישה', u'חמש', u'חמשת', u'חמישית', u'חמישי', u'חמישיות', u'חמישיים'), 6: (u'שש', u'שישה', u'שש', u'ששת', u'שישית', u'שישי', u'שישיות', u'שישיים'), 7: (u'שבע', u'שבעה', u'שבע', u'שבעת', u'שביעית', u'שביעי', u'שביעיות', u'שביעיים'), 8: (u'שמונה', u'שמונה', u'שמונה', u'שמונת', u'שמינית', u'שמיני', u'שמיניות', u'שמיניים'), 9: (u'תשע', u'תשעה', u'תשע', u'תשעת', u'תשיעית', u'תשיעי', u'תשיעיות', u'תשיעיים'), } TENS = { 0: (u'עשר', u'עשרה', u'עשר', u'עשרת', u'עשירית', u'עשירי', u'עשיריות', u'עשיריים'), 1: (u'עשרה', u'עשר'), 2: (u'שתים עשרה', u'שנים עשר'), } TWENTIES = { 2: (u'עשרים',), 3: (u'שלושים',), 4: (u'ארבעים',), 5: (u'חמישים',), 6: (u'שישים',), 7: (u'שבעים',), 8: (u'שמונים',), 9: (u'תשעים',), } HUNDREDS = { 1: (u'מאה', u'מאת'), 2: (u'מאתיים',), 3: (u'מאות',) } THOUSANDS = { 1: (u'אלף',), 2: (u'אלפיים',), 3: (u'אלפים', 'אלפי'), } LARGE = { 1: (u'מיליון', u'מיליוני'), 2: (u'מיליארד', u'מיליארדי'), 3: (u'טריליון', u'טריליוני'), 4: (u'קוודריליון', u'קוודריליוני'), 5: (u'קווינטיליון', u'קווינטיליוני'), 6: (u'סקסטיליון', u'סקסטיליוני'), 7: (u'ספטיליון', u'ספטיליוני'), 8: (u'אוקטיליון', u'אוקטיליוני'), 9: (u'נוניליון', u'נוניליוני'), 10: (u'דסיליון', u'דסיליוני'), 11: (u'אונדסיליון', u'אונדסיליוני'), 12: (u'דואודסיליון', u'דואודסיליוני'), 13: (u'טרדסיליון', u'טרדסיליוני'), 14: (u'קווטואורדסיליון', u'קווטואורדסיליוני'), 15: (u'קווינדסיליון', u'קווינדסיליוני'), 16: (u'סקסדסיליון', u'סקסדסיליוני'), 17: (u'ספטנדסיליון', u'ספטנדסיליוני'), 18: (u'אוקטודסיליון', u'אוקטודסיליוני'), 19: (u'נובמדסיליון', u'נובמדסיליוני'), 20: (u'ויגינטיליון', u'ויגינטיליוני') } AND = u'ו' DEF = u'ה' MAXVAL = int('1' + '0'*66) def chunk2word(n, i, x, gender='f', construct=False, ordinal=False, plural=False): words = [] n1, n2, n3 = get_digits(x) if n3 > 0: if construct and n == 100: words.append(HUNDREDS[n3][1]) elif n3 <= 2: words.append(HUNDREDS[n3][0]) else: words.append(ONES[n3][0] + ' ' + HUNDREDS[3][0]) if n2 > 1: words.append(TWENTIES[n2][0]) if i == 0 or x >= 11: male = gender == 'm' or i > 0 cop = (2*(construct and i == 0)+4*ordinal+2*plural) * (n < 11) if n2 == 1: if n1 == 0: words.append(TENS[n1][male + cop]) elif n1 == 2: words.append(TENS[n1][male]) else: words.append(ONES[n1][male] + ' ' + TENS[1][male]) elif n1 > 0: words.append(ONES[n1][male + cop]) construct_last = construct and (n % 1000 ** i == 0) if i == 1: if x >= 11: words[-1] = words[-1] + ' ' + THOUSANDS[1][0] elif n1 == 0: words.append(TENS[0][3] + ' ' + THOUSANDS[3][construct_last]) elif n1 <= 2: words.append(THOUSANDS[n1][0]) else: words.append(ONES[n1][3] + ' ' + THOUSANDS[3][construct_last]) elif i > 1: if x >= 11: words[-1] = words[-1] + ' ' + LARGE[i - 1][construct_last] elif n1 == 0: words.append(TENS[0][1 + 2*construct_last] + ' ' + LARGE[i - 1][construct_last]) elif n1 == 1: words.append(LARGE[i - 1][0]) else: words.append(ONES[n1][1 + 2*(construct_last or x == 2)] + ' ' + LARGE[i - 1][construct_last]) return words def int2word(n, gender='f', construct=False, ordinal=False, definite=False, plural=False): assert n == int(n) assert not construct or not ordinal assert ordinal or (not definite and not plural) if n >= MAXVAL: raise OverflowError('abs(%s) must be less than %s.' % (n, MAXVAL)) if n == 0: if ordinal: return DEF + ZERO[0] return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue words += chunk2word(n, i, x, gender=gender, construct=construct, ordinal=ordinal, plural=plural) # https://hebrew-academy.org.il/2017/01/30/%D7%95-%D7%94%D7%97%D7%99%D7%91%D7%95%D7%A8-%D7%91%D7%9E%D7%A1%D7%A4%D7%A8%D7%99%D7%9D # noqa if len(words) > 1: words[-1] = AND + words[-1] if ordinal and (n >= 11 or definite): words[0] = DEF + words[0] return ' '.join(words) class Num2Word_HE(Num2Word_Base): CURRENCY_FORMS = { 'ILS': ((u'שקל', u'שקלים'), (u'אגורה', u'אגורות')), 'EUR': ((u'אירו', u'אירו'), (u'סנט', u'סנטים')), 'USD': ((u'דולר', u'דולרים'), (u'סנט', u'סנטים')), } CURRENCY_GENDERS = { 'ILS': ('m', 'f'), 'EUR': ('m', 'm'), 'USD': ('m', 'm'), } def __init__(self, makaf='-'): super(Num2Word_HE, self).__init__() self.makaf = makaf def setup(self): super(Num2Word_HE, self).setup() self.negword = u'מינוס' self.pointword = u'נקודה' self.MAXVAL = MAXVAL def to_cardinal_float(self, value, gender='f'): 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, gender=gender)] if self.precision: out.append(self.title(self.pointword)) for i in range(self.precision): curr = int(post[i]) out.append(to_s(self.to_cardinal(curr))) return ' '.join(out) def to_cardinal(self, value, gender='f', construct=False): try: assert int(value) == value except (ValueError, TypeError, AssertionError): # https://hebrew-academy.org.il/2019/12/03/%D7%A2%D7%9C-%D7%94%D7%91%D7%A2%D7%AA-%D7%94%D7%9E%D7%A1%D7%A4%D7%A8-%D7%94%D7%9E%D7%A2%D7%95%D7%A8%D7%91 # noqa return self.to_cardinal_float(value, gender=gender) out = "" if value < 0: value = abs(value) out = "%s " % self.negword.strip() if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) return out + int2word(int(value), gender=gender, construct=construct) def to_ordinal(self, value, gender='m', definite=False, plural=False): self.verify_ordinal(value) if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) return int2word(int(value), gender=gender, ordinal=True, definite=definite, plural=plural) def pluralize(self, n, forms, currency=None, prefer_singular=False): assert n == int(n) form = 1 if n == 1 or prefer_singular and ( abs(n) >= 11 or n == 0 or currency != 'ILS'): form = 0 return forms[form] def to_currency(self, val, currency='ILS', cents=True, separator=AND, adjective=False, prefer_singular=False, prefer_singular_cents=False): left, right, is_negative = parse_currency_parts(val) if not separator.startswith(' '): separator = ' ' + separator try: cr1, cr2 = self.CURRENCY_FORMS[currency] except KeyError: raise NotImplementedError( 'Currency code "%s" not implemented for "%s"' % (currency, self.__class__.__name__)) minus_str = "%s " % self.negword.strip() if is_negative else "" try: gender1, gender2 = self.CURRENCY_GENDERS[currency] except KeyError: gender1 = gender2 = '' money_str = self.to_cardinal(left, gender=gender1, construct=left == 2) if cents: cents_str = self.to_cardinal(right, gender=gender2, construct=right == 2) else: cents_str = self._cents_terse(right, currency) sep_parts = separator.split() if sep_parts and sep_parts[-1] == AND: separator += self.makaf strings = [ minus_str, money_str, self.pluralize(left, cr1, currency=currency, prefer_singular=prefer_singular), separator, cents_str, self.pluralize(right, cr2, currency=currency, prefer_singular=prefer_singular_cents) ] if left == 1: strings[1], strings[2] = strings[2], strings[1] if right == 1: strings[4], strings[5] = strings[5], strings[4] # In Hebrew the separator is along with the following word return u'%s%s %s%s%s %s' % tuple(strings) num2words-0.5.14/num2words/lang_HU.py000066400000000000000000000136641473005321200173770ustar00rootroot00000000000000# -*- 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_EU ZERO = 'nulla' class Num2Word_HU(lang_EU.Num2Word_EU): GIGA_SUFFIX = "illiárd" MEGA_SUFFIX = "illió" def setup(self): super(Num2Word_HU, self).setup() self.negword = "mínusz " self.pointword = "egész" self.mid_numwords = [(1000, "ezer"), (100, "száz"), (90, "kilencven"), (80, "nyolcvan"), (70, "hetven"), (60, "hatvan"), (50, "ötven"), (40, "negyven"), (30, "harminc")] low_numwords = ["kilenc", "nyolc", "hét", "hat", "öt", "négy", "három", "kettő", "egy"] self.low_numwords = (['tizen' + w for w in low_numwords] + ['tíz'] + low_numwords) self.low_numwords = (['huszon' + w for w in low_numwords] + ['húsz'] + self.low_numwords + [ZERO]) self.partial_ords = { 'nulla': 'nullad', 'egy': 'egyed', 'kettő': 'ketted', 'három': 'harmad', 'négy': 'negyed', 'öt': 'ötöd', 'hat': 'hatod', 'hét': 'heted', 'nyolc': 'nyolcad', 'kilenc': 'kilenced', 'tíz': 'tized', 'húsz': 'huszad', 'harminc': 'harmincad', 'negyven': 'negyvened', 'ötven': 'ötvened', 'hatvan': 'hatvanad', 'hetven': 'hetvened', 'nyolcvan': 'nyolcvanad', 'kilencven': 'kilencvened', 'száz': 'század', 'ezer': 'ezred', 'illió': 'milliomod', 'illiárd': 'milliárdod' } def to_cardinal(self, value, zero=ZERO): if int(value) != value: return self.to_cardinal_float(value) elif value < 0: out = self.negword + self.to_cardinal(-value) elif value == 0: out = zero elif zero == '' and value == 2: out = 'két' elif value < 30: out = self.cards[value] elif value < 100: out = self.tens_to_cardinal(value) elif value < 1000: out = self.hundreds_to_cardinal(value) elif value < 10**6: out = self.thousands_to_cardinal(value) else: out = self.big_number_to_cardinal(value) return out def tens_to_cardinal(self, value): try: return self.cards[value] except KeyError: return self.cards[value // 10 * 10] + self.to_cardinal(value % 10) def hundreds_to_cardinal(self, value): hundreds = value // 100 prefix = "száz" if hundreds != 1: prefix = self.to_cardinal(hundreds, zero="") + prefix postfix = self.to_cardinal(value % 100, zero="") return prefix + postfix def thousands_to_cardinal(self, value): thousands = value // 1000 prefix = "ezer" if thousands != 1: prefix = self.to_cardinal(thousands, zero="") + prefix postfix = self.to_cardinal(value % 1000, zero="") return prefix + ('' if value <= 2000 or not postfix else '-') + postfix def big_number_to_cardinal(self, value): digits = len(str(value)) digits = digits if digits % 3 != 0 else digits - 2 exp = 10 ** (digits // 3 * 3) rest = self.to_cardinal(value % exp, '') return (self.to_cardinal(value // exp, '') + self.cards[exp] + ('-' + rest if rest else '')) def to_ordinal(self, value): if value < 0: return self.negword + self.to_ordinal(-value) if value == 1: return 'első' elif value == 2: return 'második' else: out = self.to_cardinal(value) for card_word, ord_word in self.partial_ords.items(): if out[-len(card_word):] == card_word: out = out[:-len(card_word)] + ord_word break return out + 'ik' def to_ordinal_num(self, value): self.verify_ordinal(value) return str(value) + '.' def to_year(self, val, suffix=None, longval=True): # suffix is prefix here prefix = '' if val < 0 or suffix is not None: val = abs(val) prefix = (suffix + ' ' if suffix is not None else 'i. e. ') return prefix + self.to_cardinal(val) def to_currency(self, val, currency='HUF', cents=True, separator=',', adjective=False): return super(Num2Word_HU, self).to_currency( val, currency, cents, separator, adjective) def to_cardinal_float(self, value): if abs(value) != value: return self.negword + self.to_cardinal_float(-value) left, right = str(value).split('.') return (self.to_cardinal(int(left)) + ' egész ' + self.to_cardinal(int(right)) + ' ' + self.partial_ords[self.cards[10 ** len(right)]]) num2words-0.5.14/num2words/lang_ID.py000066400000000000000000000144371473005321200173560ustar00rootroot00000000000000# -*- 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 class Num2Word_ID(): BASE = {0: [], 1: ["satu"], 2: ["dua"], 3: ["tiga"], 4: ["empat"], 5: ["lima"], 6: ["enam"], 7: ["tujuh"], 8: ["delapan"], 9: ["sembilan"]} TENS_TO = {3: "ribu", 6: "juta", 9: "miliar", 12: "triliun", 15: "kuadriliun", 18: "kuantiliun", 21: "sekstiliun", 24: "septiliun", 27: "oktiliun", 30: "noniliun", 33: "desiliun"} errmsg_floatord = "Cannot treat float number as ordinal" errmsg_negord = "Cannot treat negative number as ordinal" errmsg_toobig = "Number is too large to convert to words (abs(%s) > %s)." MAXVAL = 10 ** 36 def split_by_koma(self, number): return str(number).split('.') def split_by_3(self, number): """ starting here, it groups the number by three from the tail '1234567' -> (('1',),('234',),('567',)) :param number:str :rtype:tuple """ blocks = () length = len(number) if length < 3: blocks += ((number,),) else: len_of_first_block = length % 3 if len_of_first_block > 0: first_block = number[0:len_of_first_block], blocks += first_block, for i in range(len_of_first_block, length, 3): next_block = (number[i:i + 3],), blocks += next_block return blocks def spell(self, blocks): """ it adds the list of spelling to the blocks ( ('1',),('034',)) -> (('1',['satu']),('234',['tiga', 'puluh', 'empat']) ) :param blocks: tuple :rtype: tuple """ word_blocks = () first_block = blocks[0] if len(first_block[0]) == 1: if first_block[0] == '0': spelling = ['nol'] else: spelling = self.BASE[int(first_block[0])] elif len(first_block[0]) == 2: spelling = self.puluh(first_block[0]) else: spelling = ( self.ratus(first_block[0][0]) + self.puluh(first_block[0][1:3]) ) word_blocks += (first_block[0], spelling), for block in blocks[1:]: spelling = self.ratus(block[0][0]) + self.puluh(block[0][1:3]) block += spelling, word_blocks += block, return word_blocks def ratus(self, number): # it is used to spell if number == '1': return ['seratus'] elif number == '0': return [] else: return self.BASE[int(number)] + ['ratus'] def puluh(self, number): # it is used to spell if number[0] == '1': if number[1] == '0': return ['sepuluh'] elif number[1] == '1': return ['sebelas'] else: return self.BASE[int(number[1])] + ['belas'] elif number[0] == '0': return self.BASE[int(number[1])] else: return ( self.BASE[int(number[0])] + ['puluh'] + self.BASE[int(number[1])] ) def spell_float(self, float_part): # spell the float number word_list = [] for n in float_part: if n == '0': word_list += ['nol'] continue word_list += self.BASE[int(n)] return ' '.join(['', 'koma'] + word_list) def join(self, word_blocks, float_part): """ join the words by first join lists in the tuple :param word_blocks: tuple :rtype: str """ word_list = [] length = len(word_blocks) - 1 first_block = word_blocks[0], start = 0 if length == 1 and first_block[0][0] == '1': word_list += ['seribu'] start = 1 for i in range(start, length + 1, 1): word_list += word_blocks[i][1] if not word_blocks[i][1]: continue if i == length: break word_list += [self.TENS_TO[(length - i) * 3]] return ' '.join(word_list) + float_part def to_cardinal(self, number): if number >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (number, self.MAXVAL)) minus = '' if number < 0: minus = 'min ' float_word = '' n = self.split_by_koma(abs(number)) if len(n) == 2: float_word = self.spell_float(n[1]) return minus + self.join(self.spell(self.split_by_3(n[0])), float_word) def to_ordinal(self, number): self.verify_ordinal(number) out_word = self.to_cardinal(number) if out_word == "satu": return "pertama" return "ke" + out_word def to_ordinal_num(self, number): self.verify_ordinal(number) return "ke-" + str(number) def to_currency(self, value): return self.to_cardinal(value) + " rupiah" def to_year(self, value): return self.to_cardinal(value) def verify_ordinal(self, value): if not value == int(value): raise TypeError(self.errmsg_floatord % value) if not abs(value) == value: raise TypeError(self.errmsg_negord % value) num2words-0.5.14/num2words/lang_IS.py000066400000000000000000000110321473005321200173610ustar00rootroot00000000000000# -*- 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_EU # Genders KK = 0 # Karlkyn (male) KVK = 1 # Kvenkyn (female) HK = 2 # Hvorugkyn (neuter) GENDERS = { "einn": ("einn", "ein", "eitt"), "tveir": ("tveir", "tvær", "tvö"), "þrír": ("þrír", "þrjár", "þrjú"), "fjórir": ("fjórir", "fjórar", "fjögur"), } PLURALS = { "hundrað": ("hundrað", "hundruð"), } class Num2Word_IS(lang_EU.Num2Word_EU): GIGA_SUFFIX = "illjarður" MEGA_SUFFIX = "illjón" def setup(self): lows = ["okt", "sept", "sext", "kvint", "kvaðr", "tr", "b", "m"] self.high_numwords = self.gen_high_numwords([], [], lows) self.negword = "mínus " self.pointword = "komma" # All words should be excluded, title case is not used in Icelandic self.exclude_title = ["og", "komma", "mínus"] self.mid_numwords = [(1000, "þúsund"), (100, "hundrað"), (90, "níutíu"), (80, "áttatíu"), (70, "sjötíu"), (60, "sextíu"), (50, "fimmtíu"), (40, "fjörutíu"), (30, "þrjátíu")] self.low_numwords = ["tuttugu", "nítján", "átján", "sautján", "sextán", "fimmtán", "fjórtán", "þrettán", "tólf", "ellefu", "tíu", "níu", "átta", "sjö", "sex", "fimm", "fjórir", "þrír", "tveir", "einn", "núll"] self.ords = {"einn": "fyrsti", "tveir": "annar", "þrír": "þriðji", "fjórir": "fjórði", "fimm": "fimmti", "sex": "sjötti", "sjö": "sjöundi", "átta": "áttundi", "níu": "níundi", "tíu": "tíundi", "ellefu": "ellefti", "tólf": "tólfti"} def pluralize(self, n, noun): form = 0 if (n % 10 == 1 and n % 100 != 11) else 1 if form == 0: return noun elif self.GIGA_SUFFIX in noun: return noun.replace(self.GIGA_SUFFIX, "illjarðar") elif self.MEGA_SUFFIX in noun: return noun.replace(self.MEGA_SUFFIX, "illjónir") elif noun not in PLURALS: return noun return PLURALS[noun][form] def genderize(self, adj, noun): last = adj.split()[-1] if last not in GENDERS: return adj gender = KK if "hund" in noun or "þús" in noun: gender = HK elif "illjarð" in noun: gender = KK elif "illjón" in noun: gender = KVK return adj.replace(last, GENDERS[last][gender]) def merge(self, lpair, rpair): ltext, lnum = lpair rtext, rnum = rpair if lnum == 1 and rnum < 100: return (rtext, rnum) elif lnum < rnum: rtext = self.pluralize(lnum, rtext) ltext = self.genderize(ltext, rtext) return ("%s %s" % (ltext, rtext), lnum * rnum) elif lnum > rnum and rnum in self.cards: rtext = self.pluralize(lnum, rtext) ltext = self.genderize(ltext, rtext) return ("%s og %s" % (ltext, rtext), lnum + rnum) return ("%s %s" % (ltext, rtext), lnum + rnum) def to_ordinal(self, value): raise NotImplementedError def to_ordinal_num(self, value): raise NotImplementedError def to_year(self, val, suffix=None, longval=True): raise NotImplementedError def to_currency(self, val, longval=True): raise NotImplementedError num2words-0.5.14/num2words/lang_IT.py000066400000000000000000000212061473005321200173660ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2018-2019, Filippo Costa. 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_EU import Num2Word_EU # Globals # ------- ZERO = "zero" CARDINAL_WORDS = [ ZERO, "uno", "due", "tre", "quattro", "cinque", "sei", "sette", "otto", "nove", "dieci", "undici", "dodici", "tredici", "quattordici", "quindici", "sedici", "diciassette", "diciotto", "diciannove" ] ORDINAL_WORDS = [ ZERO, "primo", "secondo", "terzo", "quarto", "quinto", "sesto", "settimo", "ottavo", "nono", "decimo", "undicesimo", "dodicesimo", "tredicesimo", "quattordicesimo", "quindicesimo", "sedicesimo", "diciassettesimo", "diciottesimo", "diciannovesimo" ] # The script can extrapolate the missing numbers from the base forms. STR_TENS = {2: "venti", 3: "trenta", 4: "quaranta", 6: "sessanta"} # These prefixes are used for extremely big numbers. EXPONENT_PREFIXES = [ ZERO, "m", "b", "tr", "quadr", "quint", "sest", "sett", "ott", "nov", "dec" ] GENERIC_DOLLARS = ('dollaro', 'dollari') GENERIC_CENTS = ('centesimo', 'centesimi') CURRENCIES_UNA = ('GBP') # Main class # ========== class Num2Word_IT(Num2Word_EU): CURRENCY_FORMS = { 'EUR': (('euro', 'euro'), GENERIC_CENTS), 'USD': (GENERIC_DOLLARS, GENERIC_CENTS), 'GBP': (('sterlina', 'sterline'), ('penny', 'penny')), 'CNY': (('yuan', 'yuan'), ('fen', 'fen')), } MINUS_PREFIX_WORD = "meno " FLOAT_INFIX_WORD = " virgola " def setup(self): Num2Word_EU.setup(self) def __init__(self): pass def float_to_words(self, float_number, ordinal=False): if ordinal: prefix = self.to_ordinal(int(float_number)) else: prefix = self.to_cardinal(int(float_number)) float_part = str(float_number).split('.')[1] postfix = " ".join( # Drops the trailing zero and comma [self.to_cardinal(int(c)) for c in float_part] ) return prefix + Num2Word_IT.FLOAT_INFIX_WORD + postfix def tens_to_cardinal(self, number): tens = number // 10 units = number % 10 if tens in STR_TENS: prefix = STR_TENS[tens] else: prefix = CARDINAL_WORDS[tens][:-1] + "anta" postfix = omitt_if_zero(CARDINAL_WORDS[units]) return phonetic_contraction(prefix + postfix) def hundreds_to_cardinal(self, number): hundreds = number // 100 prefix = "cento" if hundreds != 1: prefix = CARDINAL_WORDS[hundreds] + prefix postfix = omitt_if_zero(self.to_cardinal(number % 100)) return phonetic_contraction(prefix + postfix) def thousands_to_cardinal(self, number): thousands = number // 1000 if thousands == 1: prefix = "mille" else: prefix = self.to_cardinal(thousands) + "mila" postfix = omitt_if_zero(self.to_cardinal(number % 1000)) # "mille" and "mila" don't need any phonetic contractions return prefix + postfix def big_number_to_cardinal(self, number): digits = [c for c in str(number)] length = len(digits) if length >= 66: raise NotImplementedError("The given number is too large.") # This is how many digits come before the "illion" term. # cento miliardi => 3 # dieci milioni => 2 # un miliardo => 1 predigits = length % 3 or 3 multiplier = digits[:predigits] exponent = digits[predigits:] # Default infix string: "milione", "biliardo", "sestilione", ecc. infix = exponent_length_to_string(len(exponent)) if multiplier == ["1"]: prefix = "un " else: prefix = self.to_cardinal(int("".join(multiplier))) # Plural form ~~~~~~~~~~~ infix = " " + infix[:-1] + "i" # Read as: Does the value of exponent equal 0? if set(exponent) != set("0"): postfix = self.to_cardinal(int("".join(exponent))) if " e " in postfix: infix += ", " else: infix += " e " else: postfix = "" return prefix + infix + postfix def to_cardinal(self, number): if number < 0: string = Num2Word_IT.MINUS_PREFIX_WORD + self.to_cardinal(-number) elif isinstance(number, float): string = self.float_to_words(number) elif number < 20: string = CARDINAL_WORDS[int(number)] elif number < 100: string = self.tens_to_cardinal(int(number)) elif number < 1000: string = self.hundreds_to_cardinal(int(number)) elif number < 1000000: string = self.thousands_to_cardinal(int(number)) else: string = self.big_number_to_cardinal(number) return accentuate(string) def to_ordinal(self, number): tens = number % 100 # Italian grammar is poorly defined here ¯\_(ツ)_/¯: # centodecimo VS centodieciesimo VS centesimo decimo? is_outside_teens = not 10 < tens < 20 if number < 0: return Num2Word_IT.MINUS_PREFIX_WORD + self.to_ordinal(-number) elif number % 1 != 0: return self.float_to_words(number, ordinal=True) elif number < 20: return ORDINAL_WORDS[int(number)] elif is_outside_teens and tens % 10 == 3: # Gets rid of the accent return self.to_cardinal(number)[:-1] + "eesimo" elif is_outside_teens and tens % 10 == 6: return self.to_cardinal(number) + "esimo" else: string = self.to_cardinal(number)[:-1] if string[-3:] == "mil": string += "l" return string + "esimo" def to_currency(self, val, currency='EUR', cents=True, separator=' e', adjective=False): result = super(Num2Word_IT, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) # Handle exception. In italian language is "un euro", # "un dollaro" etc. (not "uno euro", "uno dollaro"). # There is an exception, some currencies need "una": # e.g. "una sterlina" if currency in CURRENCIES_UNA: list_result = result.split(" ") if list_result[0] == "uno": list_result[0] = list_result[0].replace("uno", "una") result = " ".join(list_result) result = result.replace("uno", "un") return result # Utils # ===== def phonetic_contraction(string): return (string .replace("oo", "o") # ex. "centootto" .replace("ao", "o") # ex. "settantaotto" .replace("io", "o") # ex. "ventiotto" .replace("au", "u") # ex. "trentauno" .replace("iu", "u") # ex. "ventiunesimo" ) def exponent_length_to_string(exponent_length): # We always assume `exponent` to be a multiple of 3. If it's not true, then # Num2Word_IT.big_number_to_cardinal did something wrong. prefix = EXPONENT_PREFIXES[exponent_length // 6] if exponent_length % 6 == 0: return prefix + "ilione" else: return prefix + "iliardo" def accentuate(string): # This is inefficient: it may do several rewritings when deleting # half-sentence accents. However, it is the easiest method and speed is # not crucial (duh), so... return " ".join( # Deletes half-sentence accents and accentuates the last "tre" [w.replace("tré", "tre")[:-3] + "tré" # We shouldn't accentuate a single "tre": is has to be a composite # word. ~~~~~~~~~~ if w[-3:] == "tre" and len(w) > 3 # Deletes half-sentence accents anyway # ~~~~~~~~~~~~~~~~~~~~~~ else w.replace("tré", "tre") for w in string.split() ]) def omitt_if_zero(number_to_string): return "" if number_to_string == ZERO else number_to_string num2words-0.5.14/num2words/lang_JA.py000066400000000000000000000534651473005321200173600ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .compat import strtype, to_s from .currency import parse_currency_parts, prefix_currency def select_text(text, reading=False, prefer=None): """Select the correct text from the Japanese number, reading and alternatives""" # select kanji number or kana reading if reading: text = text[1] else: text = text[0] # select the preferred one or the first one from multiple alternatives if not isinstance(text, strtype): common = set(text) & set(prefer or set()) if len(common) == 1: text = common.pop() else: text = text[0] return text def rendaku_merge_pairs(lpair, rpair): """Merge lpair < rpair while applying semi-irregular rendaku rules""" ltext, lnum = lpair rtext, rnum = rpair if lnum > rnum: raise ValueError if rpair == ("ひゃく", 100): if lpair == ("さん", 3): rtext = "びゃく" elif lpair == ("ろく", 6): ltext = "ろっ" rtext = "ぴゃく" elif lpair == ("はち", 8): ltext = "はっ" rtext = "ぴゃく" elif rpair == ("せん", 1000): if lpair == ("さん", 3): rtext = "ぜん" elif lpair == ("はち", 8): ltext = "はっ" elif rpair == ("ちょう", 10**12): if lpair == ("いち", 1): ltext = "いっ" elif lpair == ("はち", 8): ltext = "はっ" elif lpair == ("じゅう", 10): ltext = "じゅっ" elif rpair == ("けい", 10**16): if lpair == ("いち", 1): ltext = "いっ" elif lpair == ("ろく", 6): ltext = "ろっ" elif lpair == ("はち", 8): ltext = "はっ" elif lpair == ("じゅう", 10): ltext = "じゅっ" elif lpair == ("ひゃく", 100): ltext = "ひゃっ" return ("%s%s" % (ltext, rtext), lnum * rnum) # Source: https://www.sljfaq.org/afaq/era-list.html # if there are multiple eras for the same year, use the last one ERA_START = [ (645, ("大化", "たいか")), (650, ("白雉", "はくち")), (686, ("朱鳥", "しゅちょう")), (701, ("大宝", "たいほう")), (704, ("慶雲", "けいうん")), (708, ("和銅", "わどう")), (715, ("霊亀", "れいき")), (717, ("養老", "ようろう")), (724, ("神亀", "じんき")), (729, ("天平", "てんぴょう")), (749, ("天平感宝", "てんぴょうかんぽう")), (749, ("天平勝宝", "てんぴょうしょうほう")), (757, ("天平宝字", "てんぴょうじょうじ")), (765, ("天平神護", "てんぴょうじんご")), (767, ("神護景雲", "じんごけいうん")), (770, ("宝亀", "ほうき")), (781, ("天応", "てんおう")), (782, ("延暦", "えんりゃく")), (806, ("大同", "だいどう")), (810, ("弘仁", "こうにん")), (823, ("天長", "てんちょう")), (834, ("承和", "じょうわ")), (848, ("嘉祥", "かしょう")), (851, ("仁寿", "にんじゅ")), (855, ("斉衡", "さいこう")), (857, ("天安", "てんあん")), (859, ("貞観", "じょうがん")), (877, ("元慶", "がんぎょう")), (885, ("仁和", "にんな")), (889, ("寛平", "かんぴょう")), (898, ("昌泰", "しょうたい")), (901, ("延喜", "えんぎ")), (923, ("延長", "えんちょう")), (931, ("承平", "じょうへい")), (938, ("天慶", "てんぎょう")), (947, ("天暦", "てんりゃく")), (957, ("天徳", "てんとく")), (961, ("応和", "おうわ")), (964, ("康保", "こうほう")), (968, ("安和", "あんな")), (970, ("天禄", "てんろく")), (974, ("天延", "てんえん")), (976, ("貞元", "じょうげん")), (979, ("天元", "てんげん")), (983, ("永観", "えいかん")), (985, ("寛和", "かんな")), (987, ("永延", "えいえん")), (989, ("永祚", "えいそ")), (990, ("正暦", "しょうりゃく")), (995, ("長徳", "ちょうとく")), (999, ("長保", "ちょうほう")), (1004, ("寛弘", "かんこう")), (1013, ("長和", "ちょうわ")), (1017, ("寛仁", "かんにん")), (1021, ("治安", "じあん")), (1024, ("万寿", "まんじゅ")), (1028, ("長元", "ちょうげん")), (1037, ("長暦", "ちょうりゃく")), (1040, ("長久", "ちょうきゅう")), (1045, ("寛徳", "かんとく")), (1046, ("永承", "えいしょう")), (1053, ("天喜", "てんぎ")), (1058, ("康平", "こうへい")), (1065, ("治暦", "じりゃく")), (1069, ("延久", "えんきゅう")), (1074, ("承保", "じょうほう")), (1078, ("承暦", "じょうりゃく")), (1081, ("永保", "えいほう")), (1084, ("応徳", "おうとく")), (1087, ("寛治", "かんじ")), (1095, ("嘉保", "かほう")), (1097, ("永長", "えいちょう")), (1098, ("承徳", "じょうとく")), (1099, ("康和", "こうわ")), (1104, ("長治", "ちょうじ")), (1106, ("嘉承", "かじょう")), (1108, ("天仁", "てんにん")), (1110, ("天永", "てんねい")), (1113, ("永久", "えいきゅう")), (1118, ("元永", "げんえい")), (1120, ("保安", "ほうあん")), (1124, ("天治", "てんじ")), (1126, ("大治", "だいじ")), (1131, ("天承", "てんしょう")), (1132, ("長承", "ちょうしょう")), (1135, ("保延", "ほうえん")), (1141, ("永治", "えいじ")), (1142, ("康治", "こうじ")), (1144, ("天養", "てんよう")), (1145, ("久安", "きゅうあん")), (1151, ("仁平", "にんぺい")), (1154, ("久寿", "きゅうじゅ")), (1156, ("保元", "ほうげん")), (1159, ("平治", "へいじ")), (1160, ("永暦", "えいりゃく")), (1161, ("応保", "おうほう")), (1163, ("長寛", "ちょうかん")), (1165, ("永万", "えいまん")), (1166, ("仁安", "にんあん")), (1169, ("嘉応", "かおう")), (1171, ("承安", "しょうあん")), (1175, ("安元", "あんげん")), (1177, ("治承", "じしょう")), (1181, ("養和", "ようわ")), (1182, ("寿永", "じゅえい")), (1184, ("元暦", "げんりゃく")), (1185, ("文治", "ぶんじ")), (1190, ("建久", "けんきゅう")), (1199, ("正治", "しょうじ")), (1201, ("建仁", "けんにん")), (1204, ("元久", "げんきゅう")), (1206, ("建永", "けんえい")), (1207, ("承元", "じょうげん")), (1211, ("建暦", "けんりゃく")), (1214, ("建保", "けんぽう")), (1219, ("承久", "じょうきゅう")), (1222, ("貞応", "じょうおう")), (1225, ("元仁", "げんにん")), (1225, ("嘉禄", "かろく")), (1228, ("安貞", "あんてい")), (1229, ("寛喜", "かんき")), (1232, ("貞永", "じょうえい")), (1233, ("天福", "てんぷく")), (1235, ("文暦", "ぶんりゃく")), (1235, ("嘉禎", "かてい")), (1239, ("暦仁", "りゃくにん")), (1239, ("延応", "えんおう")), (1240, ("仁治", "にんじ")), (1243, ("寛元", "かんげん")), (1247, ("宝治", "ほうじ")), (1249, ("建長", "けんちょう")), (1256, ("康元", "こうげん")), (1257, ("正嘉", "しょうか")), (1259, ("正元", "しょうげん")), (1260, ("文応", "ぶんおう")), (1261, ("弘長", "こうちょう")), (1264, ("文永", "ぶんえい")), (1275, ("健治", "けんじ")), (1278, ("弘安", "こうあん")), (1288, ("正応", "しょうおう")), (1293, ("永仁", "えいにん")), (1299, ("正安", "しょうあん")), (1303, ("乾元", "けんげん")), (1303, ("嘉元", "かげん")), (1307, ("徳治", "とくじ")), (1308, ("延慶", "えんきょう")), (1311, ("応長", "おうちょう")), (1312, ("正和", "しょうわ")), (1317, ("文保", "ぶんぽう")), (1319, ("元応", "げんおう")), (1321, ("元亨", "げんこう")), (1325, ("正中", "しょうちゅ")), (1326, ("嘉暦", "かりゃく")), (1329, ("元徳", "げんとく")), (1331, ("元弘", "げんこう")), (1332, ("正慶", "しょうけい")), (1334, ("建武", "けんむ")), (1336, ("延元", "えいげん")), (1338, ("暦応", "りゃくおう")), (1340, ("興国", "こうこく")), (1342, ("康永", "こうえい")), (1345, ("貞和", "じょうわ")), (1347, ("正平", "しょうへい")), (1350, ("観応", "かんおう")), (1352, ("文和", "ぶんな")), (1356, ("延文", "えんぶん")), (1361, ("康安", "こうあん")), (1362, ("貞治", "じょうじ")), (1368, ("応安", "おうあん")), (1370, ("建徳", "けんとく")), (1372, ("文中", "ぶんちゅう")), (1375, ("永和", "えいわ")), (1375, ("天授", "てんじゅ")), (1379, ("康暦", "こうりゃく")), (1381, ("永徳", "えいとく")), (1381, ("弘和", "こうわ")), (1384, ("至徳", "しとく")), (1384, ("元中", "げんちゅう")), (1387, ("嘉慶", "かけい")), (1389, ("康応", "こうおう")), (1390, ("明徳", "めいとく")), (1394, ("応永", "おうえい")), (1428, ("正長", "しょうちょう")), (1429, ("永享", "えいきょう")), (1441, ("嘉吉", "かきつ")), (1444, ("文安", "ぶんあん")), (1449, ("宝徳", "ほうとく")), (1452, ("享徳", "きょうとく")), (1455, ("康正", "こうしょう")), (1457, ("長禄", "ちょうろく")), (1461, ("寛正", "かんしょう")), (1466, ("文正", "ぶんしょう")), (1467, ("応仁", "おうにん")), (1469, ("文明", "ぶんめい")), (1487, ("長享", "ちょうきょう")), (1489, ("延徳", "えんとく")), (1492, ("明応", "めいおう")), (1501, ("文亀", "ぶんき")), (1504, ("永正", "えいしょう")), (1521, ("大永", "だいえい")), (1528, ("享禄", "きょうろく")), (1532, ("天文", "てんぶん")), (1555, ("弘治", "こうじ")), (1558, ("永禄", "えいろく")), (1570, ("元亀", "げんき")), (1573, ("天正", "てんしょう")), (1593, ("文禄", "ぶんろく")), (1596, ("慶長", "けいちょう")), (1615, ("元和", "げんな")), (1624, ("寛永", "かんえい")), (1645, ("正保", "しょうほう")), (1648, ("慶安", "けいあん")), (1652, ("承応", "じょうおう")), (1655, ("明暦", "めいれき")), (1658, ("万治", "まんじ")), (1661, ("寛文", "かんぶん")), (1673, ("延宝", "えんぽう")), (1681, ("天和", "てんな")), (1684, ("貞享", "じょうきょう")), (1688, ("元禄", "げんろく")), (1704, ("宝永", "ほうえい")), (1711, ("正徳", "しょうとく")), (1716, ("享保", "きょうほう")), (1736, ("元文", "げんぶん")), (1741, ("寛保", "かんぽう")), (1744, ("延享", "えんきょう")), (1748, ("寛延", "かんえん")), (1751, ("宝暦", "ほうれき")), (1764, ("明和", "めいわ")), (1773, ("安永", "あんえい")), (1781, ("天明", "てんめい")), (1801, ("寛政", "かんせい")), (1802, ("享和", "きょうわ")), (1804, ("文化", "ぶんか")), (1818, ("文政", "ぶんせい")), (1831, ("天保", "てんぽう")), (1845, ("弘化", "こうか")), (1848, ("嘉永", "かえい")), (1855, ("安政", "あんせい")), (1860, ("万延", "まんえい")), (1861, ("文久", "ぶんきゅう")), (1864, ("元治", "げんじ")), (1865, ("慶応", "けいおう")), (1868, ("明治", "めいじ")), (1912, ("大正", "たいしょう")), (1926, ("昭和", "しょうわ")), (1989, ("平成", "へいせい")), (2019, ("令和", "れいわ")), ] class Num2Word_JA(Num2Word_Base): CURRENCY_FORMS = { 'JPY': (('円', 'えん'), ()), } def set_high_numwords(self, high): max = 4 * len(high) for word, n in zip(high, range(max, 0, -4)): self.cards[10 ** n] = word def setup(self): self.negword = "マイナス" self.pointword = ("点", "てん") self.exclude_title = ["点", "マイナス"] self.high_numwords = [ ("万", "まん"), # 10**4 man ("億", "おく"), # 10**8 oku ("兆", "ちょう"), # 10**12 chō ("京", "けい"), # 10**16 kei ("垓", "がい"), # 10**20 gai ("秭", "し"), # 10**24 shi ("穣", "じょう"), # 10**28 jō ("溝", "こう"), # 10**32 kō ("澗", "かん"), # 10**36 kan ("正", "せい"), # 10**40 sei ("載", "さい"), # 10**44 sai ("極", "ごく"), # 10**48 goku ] self.high_numwords.reverse() self.mid_numwords = [ (1000, ("千", "せん")), (100, ("百", "ひゃく")), ] self.low_numwords = [ ("十", "じゅう"), # 10 jū ("九", "きゅう"), # 9 kyū ("八", "はち"), # 8 hachi ("七", ("なな", "しち")), # 7 nana, shichi ("六", "ろく"), # 6 roku ("五", "ご"), # 5 go ("四", ("よん", "し")), # 4 yon, shi ("三", "さん"), # 3 san ("二", "に"), # 2 ni ("一", "いち"), # 1 ichi # both are alternatives, 零 doesn't map to ゼロ or 〇 to れい (("零", "〇"), ("ゼロ", "れい")), # 0 ZERO, rei ] def merge(self, lpair, rpair): ltext, lnum = lpair rtext, rnum = rpair fmt = "%s%s" # ignore lpair if lnum is 1 and rnum is less than 10000 if lnum == 1 and rnum < 10000: return rpair # rnum is added to lnum elif lnum > rnum: return (fmt % (ltext, rtext), lnum + rnum) # rnum is multiplied by lnum elif lnum < rnum: return rendaku_merge_pairs(lpair, rpair) def _ordinal_suffix(self, reading, counter): if reading: if counter == "番": return "ばんめ" else: raise NotImplementedError( "Reading not implemented for %s" % counter) else: return counter + "目" def to_ordinal(self, value, reading=False, prefer=None, counter="番"): self.verify_ordinal(value) base = self.to_cardinal(value, reading=reading, prefer=prefer) return "%s%s" % (base, self._ordinal_suffix(reading, counter)) def to_ordinal_num(self, value, reading=False, counter="番"): return "%s%s" % (value, self._ordinal_suffix(reading, counter)) def to_year(self, val, suffix=None, longval=True, reading=False, prefer=None, era=True): year = val # Gregorian calendar if not era: prefix = "" if year < 0: year = abs(year) prefix = "きげんぜん" if reading else "紀元前" year_words = self.to_cardinal(year, reading=reading, prefer=prefer) if reading and year % 10 == 9: year_words = year_words[:-3] + "く" return "%s%s%s" % (prefix, year_words, "ねん" if reading else "年") # Era calendar (default) min_year = ERA_START[0][0] last_era_idx = len(ERA_START) - 1 if year < min_year: raise ValueError( "Can't convert years less than %s to era" % min_year) first = 0 last = last_era_idx era_idx = None while era_idx is None: mid = (first + last) // 2 if mid == last_era_idx or (ERA_START[mid][0] <= year and ERA_START[mid + 1][0] > year): era_idx = mid # if an era lasting less than a year is preferred, choose it if prefer: i = mid - 1 while i >= 0 and ERA_START[i][0] == year: # match kanji or hiragana if set(ERA_START[i][1]) & set(prefer): era_idx = i break i -= 1 # ends up at the last index where year >= ERA_START[mid][0] if year < ERA_START[mid][0]: last = mid - 1 else: first = mid + 1 era = ERA_START[era_idx] era_name = era[1][0] era_year = year - era[0] + 1 fmt = "%s%s年" if reading == "arabic": era_year_words = str(era_year) elif reading: era_name = era[1][1] era_year_words = (self.to_cardinal(era_year, reading=True, prefer=prefer) if era_year != 1 else "がん") if era_year % 10 == 9: era_year_words = era_year_words[:-3] + "く" fmt = "%s%sねん" else: era_year_words = (self.to_cardinal(era_year, reading=False, prefer=prefer) if era_year != 1 else "元") return fmt % (era_name, era_year_words) def to_currency(self, val, currency="JPY", cents=False, separator="", adjective=False, reading=False, prefer=None): left, right, is_negative = parse_currency_parts( val, is_int_with_cents=cents) try: cr1, cr2 = self.CURRENCY_FORMS[currency] if (cents or abs(val) != left) and not cr2: raise ValueError('Decimals not supported for "%s"' % 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 = self.negword if is_negative else "" return '%s%s%s%s%s' % ( minus_str, self.to_cardinal(left, reading=reading, prefer=prefer), cr1[1] if reading else cr1[0], self.to_cardinal(right, reading=reading, prefer=prefer) if cr2 else '', (cr2[1] if reading else cr2[0]) if cr2 else '', ) def splitnum(self, value, reading, prefer): for elem in self.cards: if elem > value: continue out = [] if value == 0: div, mod = 1, 0 else: div, mod = divmod(value, elem) if div == 1: out.append((select_text(self.cards[1], reading, prefer), 1)) else: if div == value: # The system tallies, eg Roman Numerals return [( div * select_text(self.cards[elem], reading, prefer), div * elem)] out.append(self.splitnum(div, reading, prefer)) out.append((select_text(self.cards[elem], reading, prefer), elem)) if mod: out.append(self.splitnum(mod, reading, prefer)) return out def to_cardinal(self, value, reading=False, prefer=None): try: assert int(value) == value except (ValueError, TypeError, AssertionError): return self.to_cardinal_float(value, reading=reading, prefer=prefer) out = "" if value < 0: value = abs(value) out = self.negword if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) val = self.splitnum(value, reading, prefer) words, _ = self.clean(val) return self.title(out + words) def to_cardinal_float(self, value, reading=False, prefer=None): prefer = prefer or ["れい"] try: float(value) == value except (ValueError, TypeError, AssertionError): 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 self.precision: out.append(self.title(self.pointword[1 if reading else 0])) for i in range(self.precision): curr = int(post[i]) out.append(to_s( self.to_cardinal(curr, reading=reading, prefer=prefer))) return "".join(out) num2words-0.5.14/num2words/lang_KN.py000066400000000000000000000160671473005321200173730ustar00rootroot00000000000000# -*- encoding: 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_EU import Num2Word_EU class Num2Word_KN(Num2Word_EU): def set_high_numwords(self, high): for n, word in self.high_numwords: self.cards[10**n] = word def setup(self): self.low_numwords = [ "ತೊಂಬತ್ತೊಂಬತ್ತು", "ತೊಂಬತ್ತೆಂಟು", "ತೊಂಬತ್ತೇಳು", "ತೊಂಬತ್ತಾರು", "ತೊಂಬತ್ತೈದು", "ತೊಂಬತ್ತ ನಾಲ್ಕು", "ತೊಂಬತ್ತ ಮೂರು", "ತೊಂಬತ್ತೆರಡು", "ತೊಂಬತ್ತೊಂದು", "ತೊಂಬತ್ತು", "ಎಂಬತ್ತೊಂಬತ್ತು", "ಎಂಬತ್ತೆಂಟು", "ಎಂಬತ್ತೇಳು", "ಎಂಬತ್ತಾರು", "ಎಂಬತ್ತೈದು", "ಎಂಬತ್ತ್ ನಾಲ್ಕು", "ಎಂಬತ್ತ್ ಮೂರು", "ಎಂಬತ್ತೆರಡು", "ಎಂಬತ್ತೊಂದು", "ಎಂಬತ್ತು", "ಎಪ್ಪತ್ತೊಂಬತ್ತು", "ಎಪ್ಪತ್ತೆಂಟು", "ಎಪ್ಪತ್ತೇಳು", "ಎಪ್ಪತ್ತಾರು", "ಎಪ್ಪತ್ತೈದು", "ಎಪ್ಪತ್ತ್ ನಾಲ್ಕು", "ಎಪ್ಪತ್ತ್ ಮೂರು", "ಎಪ್ಪತ್ತೆರಡು", "ಎಪ್ಪತ್ತೊಂದು", "ಎಪ್ಪತ್ತು", "ಅರವತ್ತೊಂಬತ್ತು", "ಅರವತ್ತೆಂಟು", "ಅರವತ್ತೇಳು", "ಅರವತ್ತಾರು", "ಅರವತ್ತೈದು", "ಅರವತ್ತ್ ನಾಲ್ಕು", "ಅರವತ್ತ್ ಮೂರು", "ಅರವತ್ತೆರಡು", "ಅರವತ್ತೊಂದು", "ಅರವತ್ತು", "ಐವತ್ತೊಂಬತ್ತು", "ಐವತ್ತೆಂಟು", "ಐವತ್ತೇಳು", "ಐವತ್ತಾರು", "ಐವತ್ತೈದು", "ಐವತ್ತ್ನಾಲ್ಕು", "ಐವತ್ತಮೂರು", "ಐವತ್ತೆರಡು", "ಐವತ್ತೊಂದು", "ಐವತ್ತು", "ನಲವತ್ತೊಂಬತ್ತು", "ನಲವತ್ತೆಂಟು", "ನಲವತ್ತೇಳು", "ನಲವತ್ತಾರು", "ನಲವತ್ತೈದು", "ನಲವತ್ತ್ ನಾಲ್ಕು", "ನಲವತ್ತ್ ಮೂರು", "ನಲವತ್ತ್ ಎರಡು", "ನಲವತ್ತೊಂದು", "ನಲವತ್ತು", "ಮೂವತ್ತ್ ಒಂಬತ್ತು", "ಮೂವತ್ಎಂಟು", "ಮೂವತ್ಏಳು", "ಮೂವತ್ಆರು", "ಮೂವತ್ತ್ ಐದು", "ಮೂವತ್ತ್ ನಾಲ್ಕು", "ಮೂವತ್ತ್ ಮೂರು", "ಮೂವತ್ತ್ಎರಡು", "ಮೂವತ್ತ್ಒಂದು", "ಮೂವತ್ತು", "ಇಪ್ಪತ್ತ್ಒಂಬತ್ತು", "ಇಪ್ಪತ್ತ್ಎಂಟು", "ಇಪ್ಪತ್ತ್ಏಳು", "ಇಪ್ಪತ್ತ್ಆರು", "ಇಪ್ಪತ್ತ್ ಐದು", "ಇಪ್ಪತ್ತ್ ನಾಲ್ಕು", "ಇಪ್ಪತ್ತ್ ಮೂರು", "ಇಪ್ಪತ್ತ್ ಎರಡು", "ಇಪ್ಪತ್ತ್ ಒಂದು", "ಇಪ್ಪತ್ತು", "ಹತ್ತೊಂಬತ್ತು", "ಹದಿನೆಂಟು", "ಹದಿನೇಳು", "ಹದಿನಾರು", "ಹದಿನೈದು", "ಹದಿನಾಲ್ಕು", "ಹದಿಮೂರು", "ಹನ್ನೆರಡು", "ಹನ್ನೊಂದು", "ಹತ್ತು", "ಒಂಬತ್ತು", "ಎಂಟು", "ಏಳು", "ಆರು", "ಐದು", "ನಾಲ್ಕು", "ಮೂರು", "ಎರಡು", "ಒಂದು", "ಸೊನ್ನೆ", ] self.mid_numwords = [(100, "ನೂರು")] self.high_numwords = [(7, "ಕೋಟಿ"), (5, "ಒಂದು ಲಕ್ಷ"), (3, "ಸಾವಿರ")] self.pointword = "ಬಿಂದು" self.modifiers = [ "್", "ಾ", "ಿ", "ೀ", "ೀ", "ು", "ೂ", "ೃ", "ೆ", "ೇ", "ೈ", "ೊ", "ೋ", "ೌ", "ೕ", ] 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: if ltext[-1] in self.modifiers: return ("%s %s" % (ltext[:-1], rtext), lnum + rnum) else: return ("%s %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_num(self, value): self.verify_ordinal(value) return "%s%s" % (value, self.to_ordinal(value)) def to_ordinal(self, value): self.verify_ordinal(value) outwords = self.to_cardinal(value) if outwords[-1] in self.modifiers: outwords = outwords[:-1] ordinal_num = outwords + "ನೇ" return ordinal_num num2words-0.5.14/num2words/lang_KO.py000066400000000000000000000121341473005321200173630ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .currency import parse_currency_parts class Num2Word_KO(Num2Word_Base): CURRENCY_FORMS = { 'KRW': ('원', None), 'USD': ('달러', '센트'), 'JPY': ('엔', None) } def set_high_numwords(self, high): max = 4 * len(high) for word, n in zip(high, range(max, 0, -4)): self.cards[10 ** n] = word def setup(self): super(Num2Word_KO, self).setup() self.negword = "마이너스 " self.pointword = "점" self.high_numwords = [ '무량대수', '불가사의', '나유타', '아승기', '항하사', '극', '재', '정', '간', '구', '양', '자', '해', '경', '조', '억', '만'] self.mid_numwords = [(1000, "천"), (100, "백")] self.low_numwords = ["십", "구", "팔", "칠", "육", "오", "사", "삼", "이", "일", "영"] self.ords = {"일": "한", "이": "두", "삼": "세", "사": "네", "오": "다섯", "육": "여섯", "칠": "일곱", "팔": "여덟", "구": "아홉", "십": "열", "이십": "스물", "삼십": "서른", "사십": "마흔", "오십": "쉰", "육십": "예순", "칠십": "일흔", "팔십": "여든", "구십": "아흔"} def merge(self, lpair, rpair): ltext, lnum = lpair rtext, rnum = rpair if lnum == 1 and rnum <= 10000: return rpair elif 10000 > lnum > rnum: return ("%s%s" % (ltext, rtext), lnum + rnum) elif lnum >= 10000 and lnum > rnum: return ("%s %s" % (ltext, rtext), lnum + rnum) else: return ("%s%s" % (ltext, rtext), lnum * rnum) def to_ordinal(self, value): self.verify_ordinal(value) if value == 1: return "첫 번째" outwords = self.to_cardinal(value).split(" ") lastwords = outwords[-1].split("백") if "십" in lastwords[-1]: ten_one = lastwords[-1].split("십") ten_one[0] = self.ords[ten_one[0] + "십"] try: ten_one[1] = self.ords[ten_one[1]] ten_one[0] = ten_one[0].replace("스무", "스물") except KeyError: pass lastwords[-1] = ''.join(ten_one) else: lastwords[-1] = self.ords[lastwords[-1]] outwords[-1] = "백 ".join(lastwords) return " ".join(outwords) + " 번째" def to_ordinal_num(self, value): self.verify_ordinal(value) return "%s 번째" % (value) def to_year(self, val, suffix=None, longval=True): if val < 0: val = abs(val) suffix = '기원전' if not suffix else suffix valtext = self.to_cardinal(val) return ("%s년" % valtext if not suffix else "%s %s년" % (suffix, valtext)) def to_currency(self, val, currency="KRW", cents=False, separator="", adjective=False): left, right, is_negative = parse_currency_parts( val, is_int_with_cents=cents) try: cr1, cr2 = self.CURRENCY_FORMS[currency] if (cents or right) and not cr2: raise ValueError('Decimals not supported for "%s"' % currency) except KeyError: raise NotImplementedError( 'Currency code "%s" not implemented for "%s"' % (currency, self.__class__.__name__)) minus_str = self.negword if is_negative else "" return '%s%s%s%s%s' % ( minus_str, ''.join(self.to_cardinal(left).split()), cr1, ' ' + self.to_cardinal(right) if cr2 else '', cr2 if cr2 else '', ) num2words-0.5.14/num2words/lang_KZ.py000066400000000000000000000066551473005321200174110ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = 'нөл' ONES = { 1: 'бір', 2: 'екі', 3: 'үш', 4: 'төрт', 5: 'бес', 6: 'алты', 7: 'жеті', 8: 'сегіз', 9: 'тоғыз', } TEN = 'он' TWENTIES = { 2: 'жиырма', 3: 'отыз', 4: 'қырық', 5: 'елу', 6: 'алпыс', 7: 'жетпіс', 8: 'сексен', 9: 'тоқсан', } HUNDRED = 'жүз' THOUSANDS = { 1: 'мың', 2: 'миллион', 3: 'миллиард', 4: 'триллион', 5: 'квадриллион', 6: 'квинтиллион', 7: 'секстиллион', 8: 'септиллион', 9: 'октиллион', 10: 'нониллион', } class Num2Word_KZ(Num2Word_Base): CURRENCY_FORMS = { 'USD': ('доллар', 'цент'), 'KZT': ('теңге', 'тиын'), } def setup(self): self.negword = "минус" self.pointword = "бүтін" def to_cardinal(self, number): n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) return u'%s %s %s' % ( self._int2word(int(left)), self.pointword, (ZERO + ' ') * leading_zero_count + self._int2word(int(right)) ) else: return self._int2word(int(n)) def pluralize(self, n, form): return form def _cents_verbose(self, number, currency): return self._int2word(number, currency == 'KZT') def _int2word(self, n, feminine=False): if n < 0: return ' '.join([self.negword, self._int2word(abs(n))]) if n == 0: return ZERO words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: if n3 > 1: words.append(ONES[n3]) words.append(HUNDRED) if n2 == 1: words.append(TEN) elif n2 > 1: words.append(TWENTIES[n2]) if n1 > 0: words.append(ONES[n1]) if i > 0: words.append(THOUSANDS[i]) return ' '.join(words) def to_ordinal(self, number): # TODO: Implement to_ordinal raise NotImplementedError() num2words-0.5.14/num2words/lang_LT.py000066400000000000000000000122651473005321200173760ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = ('nulis',) ONES_FEMININE = { 1: ('viena',), 2: ('dvi',), 3: ('trys',), 4: ('keturios',), 5: ('penkios',), 6: ('šešios',), 7: ('septynios',), 8: ('aštuonios',), 9: ('devynios',), } ONES = { 1: ('vienas',), 2: ('du',), 3: ('trys',), 4: ('keturi',), 5: ('penki',), 6: ('šeši',), 7: ('septyni',), 8: ('aštuoni',), 9: ('devyni',), } TENS = { 0: ('dešimt',), 1: ('vienuolika',), 2: ('dvylika',), 3: ('trylika',), 4: ('keturiolika',), 5: ('penkiolika',), 6: ('šešiolika',), 7: ('septyniolika',), 8: ('aštuoniolika',), 9: ('devyniolika',), } TWENTIES = { 2: ('dvidešimt',), 3: ('trisdešimt',), 4: ('keturiasdešimt',), 5: ('penkiasdešimt',), 6: ('šešiasdešimt',), 7: ('septyniasdešimt',), 8: ('aštuoniasdešimt',), 9: ('devyniasdešimt',), } HUNDRED = ('šimtas', 'šimtai') THOUSANDS = { 1: ('tūkstantis', 'tūkstančiai', 'tūkstančių'), 2: ('milijonas', 'milijonai', 'milijonų'), 3: ('milijardas', 'milijardai', 'milijardų'), 4: ('trilijonas', 'trilijonai', 'trilijonų'), 5: ('kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'), 6: ('kvintilijonas', 'kvintilijonai', 'kvintilijonų'), 7: ('sikstilijonas', 'sikstilijonai', 'sikstilijonų'), 8: ('septilijonas', 'septilijonai', 'septilijonų'), 9: ('oktilijonas', 'oktilijonai', 'oktilijonų'), 10: ('naintilijonas', 'naintilijonai', 'naintilijonų'), } GENERIC_CENTS = ('centas', 'centai', 'centų') class Num2Word_LT(Num2Word_Base): CURRENCY_FORMS = { 'LTL': (('litas', 'litai', 'litų'), GENERIC_CENTS), 'EUR': (('euras', 'eurai', 'eurų'), GENERIC_CENTS), 'USD': (('doleris', 'doleriai', 'dolerių'), GENERIC_CENTS), 'GBP': ( ('svaras sterlingų', 'svarai sterlingų', 'svarų sterlingų'), ('pensas', 'pensai', 'pensų') ), 'PLN': ( ('zlotas', 'zlotai', 'zlotų'), ('grašis', 'grašiai', 'grašių')), 'RUB': ( ('rublis', 'rubliai', 'rublių'), ('kapeika', 'kapeikos', 'kapeikų') ), } def setup(self): self.negword = "minus" self.pointword = "kablelis" def pluralize(self, n, forms): n1, n2, n3 = get_digits(n) if n2 == 1 or n1 == 0 or n == 0: return forms[2] elif n1 == 1: return forms[0] else: return forms[1] def to_cardinal(self, number): n = str(number).replace(',', '.') base_str, n = self.parse_minus(n) if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + self._int2word(int(right))) return '%s%s %s %s' % ( base_str, self._int2word(int(left)), self.pointword, decimal_part ) else: return "%s%s" % (base_str, self._int2word(int(n))) def to_ordinal(self, number): raise NotImplementedError() def _cents_verbose(self, number, currency): return self._int2word(number, currency == 'RUB') def _int2word(self, n, feminine=False): if n == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: words.append(ONES[n3][0]) if n3 > 1: words.append(HUNDRED[1]) else: words.append(HUNDRED[0]) if n2 > 1: words.append(TWENTIES[n2][0]) if n2 == 1: words.append(TENS[n1][0]) elif n1 > 0: if (i == 1 or feminine and i == 0) and n < 1000: words.append(ONES_FEMININE[n1][0]) else: words.append(ONES[n1][0]) if i > 0: words.append(self.pluralize(x, THOUSANDS[i])) return ' '.join(words) num2words-0.5.14/num2words/lang_LV.py000066400000000000000000000134141473005321200173750ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = ('nulle',) ONES = { 1: ('viens',), 2: ('divi',), 3: ('trīs',), 4: ('četri',), 5: ('pieci',), 6: ('seši',), 7: ('septiņi',), 8: ('astoņi',), 9: ('deviņi',), } TENS = { 0: ('desmit',), 1: ('vienpadsmit',), 2: ('divpadsmit',), 3: ('trīspadsmit',), 4: ('četrpadsmit',), 5: ('piecpadsmit',), 6: ('sešpadsmit',), 7: ('septiņpadsmit',), 8: ('astoņpadsmit',), 9: ('deviņpadsmit',), } TWENTIES = { 2: ('divdesmit',), 3: ('trīsdesmit',), 4: ('četrdesmit',), 5: ('piecdesmit',), 6: ('sešdesmit',), 7: ('septiņdesmit',), 8: ('astoņdesmit',), 9: ('deviņdesmit',), } HUNDRED = ('simts', 'simti', 'simtu') THOUSANDS = { 1: ('tūkstotis', 'tūkstoši', 'tūkstošu'), 2: ('miljons', 'miljoni', 'miljonu'), 3: ('miljards', 'miljardi', 'miljardu'), 4: ('triljons', 'triljoni', 'triljonu'), 5: ('kvadriljons', 'kvadriljoni', 'kvadriljonu'), 6: ('kvintiljons', 'kvintiljoni', 'kvintiljonu'), 7: ('sikstiljons', 'sikstiljoni', 'sikstiljonu'), 8: ('septiljons', 'septiljoni', 'septiljonu'), 9: ('oktiljons', 'oktiljoni', 'oktiljonu'), 10: ('nontiljons', 'nontiljoni', 'nontiljonu'), } GENERIC_DOLLARS = ('dolārs', 'dolāri', 'dolāru') GENERIC_CENTS = ('cents', 'centi', 'centu') GENERIC_KRONA = ('krona', 'kronas', 'kronu') GENERIC_ERA = ('ēre', 'ēras', 'ēru') class Num2Word_LV(Num2Word_Base): """ Sadly we have a legal form (used in legal and finance documents): http://www.eiro.lv/files/upload/files/Eiro_rakstiba-1.pdf https://likumi.lv/doc.php?id=254741 http://eur-lex.europa.eu/legal-content/LV/TXT/HTML/?uri=CELEX:31998R0974&from=LV Source: http://publications.europa.eu/code/lv/lv-5000500.htm """ CURRENCY_FORMS = { 'AUD': (GENERIC_DOLLARS, GENERIC_CENTS), 'CAD': (GENERIC_DOLLARS, GENERIC_CENTS), # repalced by EUR 'EEK': (GENERIC_KRONA, GENERIC_CENTS), 'EUR': (('eiro', 'eiro', 'eiro'), GENERIC_CENTS), 'EUR_LEGAL': (('euro', 'euro', 'euro'), GENERIC_CENTS), 'GBP': ( ('sterliņu mārciņa', 'sterliņu mārciņas', 'sterliņu mārciņu'), ('penss', 'pensi', 'pensu')), # replaced by EUR 'LTL': (('lits', 'liti', 'litu'), GENERIC_CENTS), # replaced by EUR 'LVL': (('lats', 'lati', 'latu'), ('santīms', 'santīmi', 'santīmu')), 'USD': (GENERIC_DOLLARS, GENERIC_CENTS), 'RUB': (('rublis', 'rubļi', 'rubļu'), ('kapeika', 'kapeikas', 'kapeiku')), 'SEK': (GENERIC_KRONA, GENERIC_ERA), 'NOK': (GENERIC_KRONA, GENERIC_ERA), 'PLN': (('zlots', 'zloti', 'zlotu'), ('grasis', 'graši', 'grašu')), } CURRENCY_ADJECTIVES = { 'AUD': 'Austrālijas', 'CAD': 'Kanādas', 'EEK': 'Igaunijas', 'USD': 'ASV', 'RUB': 'Kreivijas', 'SEK': 'Zviedrijas', 'NOK': 'Norvēģijas', } def setup(self): self.negword = "mīnus" self.pointword = "komats" def to_cardinal(self, number): n = str(number).replace(',', '.') base_str, n = self.parse_minus(n) if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + self._int2word(int(right))) return '%s%s %s %s' % ( base_str, self._int2word(int(left)), self.pointword, decimal_part ) else: return "%s%s" % (base_str, self._int2word(int(n))) def pluralize(self, n, forms): form = 0 if (n % 10 == 1 and n % 100 != 11) else 1 if n != 0 else 2 return forms[form] def to_ordinal(self, number): raise NotImplementedError() def _int2word(self, n): if n == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: if n3 == 1 and n2 == 0 and n1 > 0: words.append(HUNDRED[2]) elif n3 > 1: words.append(ONES[n3][0]) words.append(HUNDRED[1]) else: words.append(HUNDRED[0]) if n2 > 1: words.append(TWENTIES[n2][0]) if n2 == 1: words.append(TENS[n1][0]) elif n1 > 0 and not (i > 0 and x == 1): words.append(ONES[n1][0]) if i > 0: words.append(self.pluralize(x, THOUSANDS[i])) return ' '.join(words) num2words-0.5.14/num2words/lang_NL.py000066400000000000000000000130721473005321200173650ustar00rootroot00000000000000# -*- 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_EU import Num2Word_EU class Num2Word_NL(Num2Word_EU): CURRENCY_FORMS = { 'EUR': (('euro', 'euro'), ('cent', 'cent')), 'GBP': (('pond', 'pond'), ('penny', 'pence')), 'USD': (('dollar', 'dollar'), ('cent', 'cent')), 'CNY': (('yuan', 'yuan'), ('jiao', 'fen')), } GIGA_SUFFIX = "iljard" MEGA_SUFFIX = "iljoen" def setup(self): super(Num2Word_NL, self).setup() self.negword = "min " self.pointword = "komma" # "Cannot treat float %s as ordinal." self.errmsg_floatord = ( "Het zwevende puntnummer %s kan niet omgezet worden " + "naar een ordernummer." ) # "type(((type(%s)) ) not in [long, int, float]" self.errmsg_nonnum = ( "Alleen nummers (type (%s)) kunnen naar " + "woorden omgezet worden." ) # "Cannot treat negative num %s as ordinal." self.errmsg_negord = ( "Het negatieve getal %s kan niet omgezet " + "worden naar een ordernummer." ) # "abs(%s) must be less than %s." self.errmsg_toobig = "Het getal %s moet minder zijn dan %s." self.exclude_title = [] lows = ["non", "okt", "sept", "sext", "quint", "quadr", "tr", "b", "m"] units = ["", "un", "duo", "tre", "quattuor", "quin", "sex", "sept", "okto", "novem"] tens = ["dez", "vigint", "trigint", "quadragint", "quinquagint", "sexagint", "septuagint", "oktogint", "nonagint"] self.high_numwords = ( ["zend"] + self.gen_high_numwords(units, tens, lows)) self.mid_numwords = [(1000, "duizend"), (100, "honderd"), (90, "negentig"), (80, "tachtig"), (70, "zeventig"), (60, "zestig"), (50, "vijftig"), (40, "veertig"), (30, "dertig")] self.low_numwords = ["twintig", "negentien", "achttien", "zeventien", "zestien", "vijftien", "veertien", "dertien", "twaalf", "elf", "tien", "negen", "acht", "zeven", "zes", "vijf", "vier", "drie", "twee", "één", "nul"] # Wiktionary says it is "nulde", not "nulte" or "nule" # https://en.wiktionary.org/wiki/nulde self.ords = {"nul": "nuld", "één": "eerst", "twee": "tweed", "drie": "derd", "vier": "vierd", "vijf": "vijfd", "zes": "zesd", "zeven": "zevend", "acht": "achtst", "negen": "negend", "tien": "tiend", "elf": "elfd", "twaalf": "twaalfd", "ig": "igst", "erd": "erdst", "end": "endst", "joen": "joenst", "rd": "rdst"} def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 10 ** 6: return next ctext = "een" if nnum > cnum: if nnum >= 10 ** 6: ctext += " " val = cnum * nnum else: if nnum < 10 < cnum < 100: if nnum == 1: ntext = "een" if ntext.endswith("e"): ntext += "ën" # "n" else: ntext += "en" ntext, ctext = ctext, ntext # + "en" elif cnum >= 10 ** 6: ctext += " " val = cnum + nnum word = ctext + ntext return word, val def to_ordinal(self, value): self.verify_ordinal(value) outword = self.to_cardinal(value) for key in self.ords: if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break return outword + "e" def to_ordinal_num(self, value): self.verify_ordinal(value) return str(value) + "e" def pluralize(self, n, forms): """ :param n: :param forms: :return: gettext form is nplurals=2; plural=(n != 1); but this claims https://onzetaal.nl/taaladvies/euro-euros/ not sure if it's applied only to euro """ return forms[0] def to_year(self, val, longval=True): if not (val // 100) % 10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt="honderd", longval=longval) num2words-0.5.14/num2words/lang_NO.py000066400000000000000000000115301473005321200173650ustar00rootroot00000000000000# -*- 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_EU class Num2Word_NO(lang_EU.Num2Word_EU): GIGA_SUFFIX = "illard" MEGA_SUFFIX = "illion" CURRENCY_FORMS = {'NOK': (('krone', 'kroner'), ('øre', 'øre'))} 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 setup(self): super(Num2Word_NO, self).setup() self.negword = "minus " self.pointword = "komma" self.exclude_title = ["og", "komma", "minus"] self.mid_numwords = [(1000, "tusen"), (100, "hundre"), (90, "nitti"), (80, "\xe5tti"), (70, "sytti"), (60, "seksti"), (50, "femti"), (40, "f\xf8rti"), (30, "tretti")] self.low_numwords = ["tjue", "nitten", "atten", "sytten", "seksten", "femten", "fjorten", "tretten", "tolv", "elleve", "ti", "ni", "\xe5tte", "syv", "seks", "fem", "fire", "tre", "to", "en", "null"] self.ords_pl = {"to": "andre", "tre": "tredje", "fire": "fjerde", "fem": "femte", "seks": "sjette", "syv": "syvende", "\xe5tte": "\xe5ttende", "ni": "niende", "ti": "tiende", "elleve": "ellevte", "tolv": "tolvte", "fjorten": "fjortende", "femten": "femtende", "seksten": "sekstende", "sytten": "syttende", "atten": "attende", "nitten": "nittende", "tjue": "tjuende", "hundre": "hundrede", "tusen": "tusende", "million": "millionte"} # this needs to be done separately to not block 13-19 to_ordinal self.ords_sg = {"en": "f\xf8rste"} 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 og %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) outword = self.to_cardinal(value) for key in self.ords_pl: if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords_pl[key] break for key in self.ords_sg: if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords_sg[key] break return outword def to_ordinal_num(self, value): self.verify_ordinal(value) return str(value) + "." def to_year(self, val, longval=True): if not (val // 100) % 10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt="hundre", jointxt="og", longval=longval) def to_currency(self, val, currency='NOK', cents=True, separator=' og', adjective=False): result = super(Num2Word_NO, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) # do not print "og null øre" result = result.replace(' og null øre', '') return result num2words-0.5.14/num2words/lang_PL.py000066400000000000000000000173021473005321200173670ustar00rootroot00000000000000# -*- 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 import itertools from .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = ('zero',) ONES = { 1: ('jeden',), 2: ('dwa',), 3: ('trzy',), 4: ('cztery',), 5: ('pięć',), 6: ('sześć',), 7: ('siedem',), 8: ('osiem',), 9: ('dziewięć',), } ONES_ORDINALS = { 1: ('pierwszy', "pierwszo"), 2: ('drugi', "dwu"), 3: ('trzeci', "trzy"), 4: ('czwarty', "cztero"), 5: ('piąty', "pięcio"), 6: ('szósty', "sześcio"), 7: ('siódmy', "siedmio"), 8: ('ósmy', "ośmio"), 9: ('dziewiąty', "dziewięcio"), 10: ('dziesiąty', "dziesięcio"), 11: ('jedenasty', "jedenasto"), 12: ('dwunasty', "dwunasto"), 13: ('trzynasty', "trzynasto"), 14: ('czternasty', "czternasto"), 15: ('piętnasty', "piętnasto"), 16: ('szesnasty', "szesnasto"), 17: ('siedemnasty', "siedemnasto"), 18: ('osiemnasty', "osiemnasto"), 19: ('dziewiętnasty', "dziewiętnasto"), } TENS = { 0: ('dziesięć',), 1: ('jedenaście',), 2: ('dwanaście',), 3: ('trzynaście',), 4: ('czternaście',), 5: ('piętnaście',), 6: ('szesnaście',), 7: ('siedemnaście',), 8: ('osiemnaście',), 9: ('dziewiętnaście',), } TWENTIES = { 2: ('dwadzieścia',), 3: ('trzydzieści',), 4: ('czterdzieści',), 5: ('pięćdziesiąt',), 6: ('sześćdziesiąt',), 7: ('siedemdziesiąt',), 8: ('osiemdziesiąt',), 9: ('dziewięćdziesiąt',), } TWENTIES_ORDINALS = { 2: ('dwudziesty', "dwudziesto"), 3: ('trzydziesty', "trzydiesto"), 4: ('czterdziesty', "czterdziesto"), 5: ('pięćdziesiąty', "pięćdziesięcio"), 6: ('sześćdziesiąty', "sześćdziesięcio"), 7: ('siedemdziesiąty', "siedemdziesięcio"), 8: ('osiemdziesiąty', "osiemdziesięcio"), 9: ('dziewięćdziesiąty', "dziewięćdziesięcio"), } HUNDREDS = { 1: ('sto',), 2: ('dwieście',), 3: ('trzysta',), 4: ('czterysta',), 5: ('pięćset',), 6: ('sześćset',), 7: ('siedemset',), 8: ('osiemset',), 9: ('dziewięćset',), } HUNDREDS_ORDINALS = { 1: ('setny', "stu"), 2: ('dwusetny', "dwustu"), 3: ('trzysetny', "trzystu"), 4: ('czterysetny', "czterystu"), 5: ('pięćsetny', "pięcset"), 6: ('sześćsetny', "sześćset"), 7: ('siedemsetny', "siedemset"), 8: ('osiemsetny', "ośiemset"), 9: ('dziewięćsetny', "dziewięćset"), } THOUSANDS = { 1: ('tysiąc', 'tysiące', 'tysięcy'), # 10^3 } prefixes_ordinal = { 1: "tysięczny", 2: "milionowy", 3: "milairdowy" } prefixes = ( # 10^(6*x) "mi", # 10^6 "bi", # 10^12 "try", # 10^18 "kwadry", # 10^24 "kwinty", # 10^30 "seksty", # 10^36 "septy", # 10^42 "okty", # 10^48 "nony", # 10^54 "decy" # 10^60 ) suffixes = ("lion", "liard") # 10^x or 10^(x+3) for idx, (p, s) in enumerate(itertools.product(prefixes, suffixes)): name = p + s THOUSANDS[idx+2] = (name, name + 'y', name + 'ów') class Num2Word_PL(Num2Word_Base): CURRENCY_FORMS = { 'PLN': ( ('złoty', 'złote', 'złotych'), ('grosz', 'grosze', 'groszy') ), 'EUR': ( ('euro', 'euro', 'euro'), ('cent', 'centy', 'centów') ), 'USD': ( ( 'dolar amerykański', 'dolary amerykańskie', 'dolarów amerykańskich' ), ( 'cent', 'centy', 'centów' ) ), } def setup(self): self.negword = "minus" self.pointword = "przecinek" def to_cardinal(self, number): n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + self._int2word(int(right))) return u'%s %s %s' % ( self._int2word(int(left)), self.pointword, decimal_part ) else: return self._int2word(int(n)) def pluralize(self, n, forms): if n == 1: form = 0 elif 5 > n % 10 > 1 and (n % 100 < 10 or n % 100 > 20): form = 1 else: form = 2 return forms[form] def last_fragment_to_ordinal(self, last, words, level): n1, n2, n3 = get_digits(last) last_two = n2*10+n1 if last_two == 0: words.append(HUNDREDS_ORDINALS[n3][level]) elif level == 1 and last == 1: return elif last_two < 20: if n3 > 0: words.append(HUNDREDS[n3][level]) words.append(ONES_ORDINALS[last_two][level]) elif last_two % 10 == 0: if n3 > 0: words.append(HUNDREDS[n3][level]) words.append(TWENTIES_ORDINALS[n2][level]) else: if n3 > 0: words.append(HUNDREDS[n3][0]) words.append(TWENTIES_ORDINALS[n2][0]) words.append(ONES_ORDINALS[n1][0]) def to_ordinal(self, number): if number % 1 != 0: raise NotImplementedError() words = [] fragments = list(splitbyx(str(number), 3)) level = 0 last = fragments[-1] while last == 0: level = level+1 fragments.pop() last = fragments[-1] if len(fragments) > 1: pre_part = self._int2word(number-(last*1000**level)) words.append(pre_part) self.last_fragment_to_ordinal(last, words, 0 if level == 0 else 1) output = " ".join(words) if last == 1 and level > 0 and output != "": output = output + " " if level > 0: output = output + prefixes_ordinal[level] return output def _int2word(self, n): if n == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: words.append(HUNDREDS[n3][0]) if n2 > 1: words.append(TWENTIES[n2][0]) if n2 == 1: words.append(TENS[n1][0]) elif n1 > 0 and not (i > 0 and x == 1): words.append(ONES[n1][0]) if i > 0: words.append(self.pluralize(x, THOUSANDS[i])) return ' '.join(words) num2words-0.5.14/num2words/lang_PT.py000066400000000000000000000204671473005321200174050ustar00rootroot00000000000000# -*- 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, unicode_literals import re from .lang_EU import Num2Word_EU DOLLAR = ('dólar', 'dólares') CENTS = ('cêntimo', 'cêntimos') class Num2Word_PT(Num2Word_EU): CURRENCY_FORMS = { 'AUD': (DOLLAR, CENTS), 'CAD': (DOLLAR, CENTS), 'EUR': (('euro', 'euros'), CENTS), 'GBP': (('libra', 'libras'), ('péni', 'pence')), 'USD': (DOLLAR, CENTS), } GIGA_SUFFIX = None MEGA_SUFFIX = "ilião" def setup(self): super(Num2Word_PT, self).setup() lows = ["quatr", "tr", "b", "m"] self.high_numwords = self.gen_high_numwords([], [], lows) self.negword = "menos " self.pointword = "vírgula" self.exclude_title = ["e", "vírgula", "menos"] self.mid_numwords = [ (1000, "mil"), (100, "cem"), (90, "noventa"), (80, "oitenta"), (70, "setenta"), (60, "sessenta"), (50, "cinquenta"), (40, "quarenta"), (30, "trinta") ] self.low_numwords = [ "vinte", "dezanove", "dezoito", "dezassete", "dezasseis", "quinze", "catorze", "treze", "doze", "onze", "dez", "nove", "oito", "sete", "seis", "cinco", "quatro", "três", "dois", "um", "zero" ] self.ords = [ { 0: "", 1: "primeiro", 2: "segundo", 3: "terceiro", 4: "quarto", 5: "quinto", 6: "sexto", 7: "sétimo", 8: "oitavo", 9: "nono", }, { 0: "", 1: "décimo", 2: "vigésimo", 3: "trigésimo", 4: "quadragésimo", 5: "quinquagésimo", 6: "sexagésimo", 7: "septuagésimo", 8: "octogésimo", 9: "nonagésimo", }, { 0: "", 1: "centésimo", 2: "ducentésimo", 3: "tricentésimo", 4: "quadrigentésimo", 5: "quingentésimo", 6: "seiscentésimo", 7: "septigentésimo", 8: "octigentésimo", 9: "nongentésimo", }, ] self.thousand_separators = { 3: "milésimo", 6: "milionésimo", 9: "milésimo milionésimo", 12: "bilionésimo", 15: "milésimo bilionésimo" } self.hundreds = { 1: "cento", 2: "duzentos", 3: "trezentos", 4: "quatrocentos", 5: "quinhentos", 6: "seiscentos", 7: "setecentos", 8: "oitocentos", 9: "novecentos", } def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next ctext = "um" elif cnum == 100 and not nnum % 1000 == 0: ctext = "cento" if nnum < cnum: if cnum < 100: return ("%s e %s" % (ctext, ntext), cnum + nnum) return ("%s e %s" % (ctext, ntext), cnum + nnum) elif (not nnum % 1000000000) and cnum > 1: ntext = ntext[:-4] + "liões" elif (not nnum % 1000000) and cnum > 1: ntext = ntext[:-4] + "lhões" # correct "milião" to "milhão" if ntext == 'milião': ntext = 'milhão' if nnum == 100: ctext = self.hundreds[cnum] ntext = "" else: ntext = " " + ntext return (ctext + ntext, cnum * nnum) def to_cardinal(self, value): result = super(Num2Word_PT, self).to_cardinal(value) # Transforms "mil e cento e catorze" into "mil cento e catorze" # Transforms "cem milhões e duzentos mil e duzentos e dez" em "cem # milhões duzentos mil duzentos e dez" but "cem milhões e duzentos # mil e duzentos" in "cem milhões duzentos mil e duzentos" and not in # "cem milhões duzentos mil duzentos" for ext in ( 'mil', 'milhão', 'milhões', 'mil milhões', 'bilião', 'biliões', 'mil biliões'): if re.match('.*{} e \\w*entos? (?=.*e)'.format(ext), result): result = result.replace( '{} e'.format(ext), '{}'.format(ext) ) return result # for the ordinal conversion the code is similar to pt_BR code, # although there are other rules that are probably more correct in # Portugal. Concerning numbers from 2000th on, saying "dois # milésimos" instead of "segundo milésimo" (the first number # would be used in the cardinal form instead of the ordinal) is better. # This was not implemented. # source: # https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/a-forma-por-extenso-de-2000-e-de-outros-ordinais/16428 def to_ordinal(self, value): # Before changing this function remember this is used by pt-BR # so act accordingly self.verify_ordinal(value) result = [] value = str(value) thousand_separator = '' for idx, char in enumerate(value[::-1]): if idx and idx % 3 == 0: thousand_separator = self.thousand_separators[idx] if char != '0' and thousand_separator: # avoiding "segundo milionésimo milésimo" for 6000000, # for instance result.append(thousand_separator) thousand_separator = '' result.append(self.ords[idx % 3][int(char)]) result = ' '.join(result[::-1]) result = result.strip() result = re.sub('\\s+', ' ', result) if result.startswith('primeiro') and value != '1': # avoiding "primeiro milésimo", "primeiro milionésimo" and so on result = result[9:] return result def to_ordinal_num(self, value): # Before changing this function remember this is used by pt-BR # so act accordingly self.verify_ordinal(value) return "%sº" % (value) def to_year(self, val, longval=True): # Before changing this function remember this is used by pt-BR # so act accordingly if val < 0: return self.to_cardinal(abs(val)) + ' antes de Cristo' return self.to_cardinal(val) def to_currency(self, val, currency='EUR', cents=True, separator=' e', adjective=False): # change negword because base.to_currency() does not need space after backup_negword = self.negword self.negword = self.negword[:-1] result = super(Num2Word_PT, self).to_currency( val, currency=currency, cents=cents, separator=separator, adjective=adjective) # undo the change on negword self.negword = backup_negword # transforms "milhões euros" em "milhões de euros" cr1, _ = self.CURRENCY_FORMS[currency] for ext in ( 'milhão', 'milhões', 'bilião', 'biliões', 'trilião', 'triliões'): if re.match('.*{} (?={})'.format(ext, cr1[1]), result): result = result.replace( '{}'.format(ext), '{} de'.format(ext), 1 ) # do not print "e zero cêntimos" result = result.replace(' e zero cêntimos', '') return result num2words-0.5.14/num2words/lang_PT_BR.py000066400000000000000000000072741473005321200177710ustar00rootroot00000000000000# -*- 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, unicode_literals import re from . import lang_PT class Num2Word_PT_BR(lang_PT.Num2Word_PT): 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 + "ilhão" def setup(self): super(Num2Word_PT_BR, self).setup() self.low_numwords[1] = 'dezenove' self.low_numwords[3] = 'dezessete' self.low_numwords[4] = 'dezesseis' self.thousand_separators = { 3: "milésimo", 6: "milionésimo", 9: "bilionésimo", 12: "trilionésimo", 15: "quadrilionésimo" } def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1: if nnum < 1000000: return next ctext = "um" elif cnum == 100 and nnum % 1000 != 0: ctext = "cento" if nnum < cnum: if cnum < 100: return ("%s e %s" % (ctext, ntext), cnum + nnum) return ("%s e %s" % (ctext, ntext), cnum + nnum) elif (not nnum % 1000000) and cnum > 1: ntext = ntext[:-4] + "lhões" if nnum == 100: ctext = self.hundreds[cnum] ntext = "" else: ntext = " " + ntext return (ctext + ntext, cnum * nnum) def to_cardinal(self, value): result = lang_PT.Num2Word_EU.to_cardinal(self, value) # Transforms "mil E cento e catorze reais" into "mil, cento e catorze # reais" for ext in ( 'mil', 'milhão', 'milhões', 'bilhão', 'bilhões', 'trilhão', 'trilhões', 'quatrilhão', 'quatrilhões'): if re.match('.*{} e \\w*entos? (?=.*e)'.format(ext), result): result = result.replace( '{} e'.format(ext), '{},'.format(ext), 1 ) return result def to_currency(self, val, longval=True): integer_part, decimal_part = ('%.2f' % val).split('.') result = self.to_cardinal(int(integer_part)) appended_currency = False for ext in ( 'milhão', 'milhões', 'bilhão', 'bilhões', 'trilhão', 'trilhões', 'quatrilhão', 'quatrilhões'): if result.endswith(ext): result += ' de reais' appended_currency = True if result in ['um', 'menos um']: result += ' real' appended_currency = True if not appended_currency: result += ' reais' if int(decimal_part): cents = self.to_cardinal(int(decimal_part)) result += ' e ' + cents if cents == 'um': result += ' centavo' else: result += ' centavos' return result num2words-0.5.14/num2words/lang_RO.py000066400000000000000000000152411473005321200173740ustar00rootroot00000000000000# -*- 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_EU class Num2Word_RO(lang_EU.Num2Word_EU): GIGA_SUFFIX = "iliard/e" MEGA_SUFFIX = "ilion" # inflection for mi/billion follows different rule MEGA_SUFFIX_I = "ilioane" GIGA_SUFFIX_I = "iliarde" def setup(self): super(Num2Word_RO, self).setup() self.negword = "minus " self.pointword = "virgulă" self.exclude_title = ["și", "virgulă", "minus"] self.errmsg_toobig = ( "Numărul e prea mare pentru a \ fi convertit în cuvinte (abs(%s) > %s)." ) self.mid_numwords = [(1000, "mie/i"), (100, "sută/e"), (90, "nouăzeci"), (80, "optzeci"), (70, "șaptezeci"), (60, "șaizeci"), (50, "cincizeci"), (40, "patruzeci"), (30, "treizeci")] self.low_numwords = ["douăzeci", "nouăsprezece", "optsprezece", "șaptesprezece", "șaisprezece", "cincisprezece", "paisprezece", "treisprezece", "doisprezece", "unsprezece", "zece", "nouă", "opt", "șapte", "șase", "cinci", "patru", "trei", "doi", "unu", "zero"] self.gen_numwords = ["", "o", "două", "trei", "patru", "cinci", "șase", "șapte", "opt", "nouă"] self.gen_numwords_n = ["", "un", "două", "trei", "patru", "cinci", "șase", "șapte", "opt", "nouă"] self.numwords_inflections = { 100: self.gen_numwords, 1000: self.gen_numwords, 1000000: self.gen_numwords_n, 1000000000: self.gen_numwords_n } self.ords = {"unu": "primul", "doi": "al doilea", "three": "al treilea", "cinci": "al cincilea", "opt": "al optulea", "nouă": "al nouălea", "doisprezece": "al doisprezecelea"} def merge(self, lpair, rpair): ltext, lnum = lpair rtext, rnum = rpair rtext_i = self.inflect(rnum, rtext, lnum) if 1 <= lnum < 10: if rnum not in self.numwords_inflections: return (rtext, rnum) else: rtext_i = self.inflect(lnum * rnum, rtext, lnum) lresult = (self.numwords_inflections[rnum][lnum], rtext_i) return ("%s %s" % lresult, rnum) elif 10 < lnum < 100: if lnum % 10 == 0: if rnum in self.numwords_inflections: rtext_i = self.inflect(lnum * rnum, rtext, lnum) return ("%s %s" % (ltext, rtext_i), lnum * rnum) else: return ("%s și %s" % (ltext, rtext), lnum + rnum) else: rtext_i = self.inflect(lnum * rnum, rtext, lnum) ltext_i = ltext if lnum % 10 != 2 \ else ltext.replace("doi", "două") return ("%s %s" % (ltext_i, rtext_i), lnum * rnum) else: if rnum in self.numwords_inflections: rtext_i = self.inflect(lnum * rnum, rtext, lnum) return ("%s %s" % (ltext, rtext_i), lnum * rnum) def to_ordinal(self, value): self.verify_ordinal(value) if value == 1: return "primul" else: value = self.to_cardinal(value) return "al %slea" % (value) def to_ordinal_num(self, value): self.verify_ordinal(value) if value == 1: return "1-ul" return "al %s-lea" % (value) def pluralize(self, n, forms): if n == 1: form = 0 elif n == 0 or (n % 100 > 0 and n % 100 < 20): form = 1 else: form = 2 return forms[form] def inflect(self, value, text, side_effect=-1): text = text.split("/") result = text[0] if len(text) > 1: forms = [ text[0], text[0][:-1] + text[1], "de " + text[0][:-1] + text[1] ] result = self.pluralize(side_effect, forms) # mega inflections are different if side_effect > 1 and result.endswith(self.MEGA_SUFFIX): result = result.replace(self.MEGA_SUFFIX, self.MEGA_SUFFIX_I) elif side_effect > 1 and result.endswith("iliare"): result = result.replace("iliare", self.GIGA_SUFFIX_I) return result def to_currency(self, val, currency="RON", cents=False, separator=" și", adjective=False): # romanian currency has a particularity for numeral: one self.gen_numwords[1] = "una" result = super(Num2Word_RO, self).to_currency( int(round(val*100)), currency, True, separator, adjective ) self.gen_numwords[1] = "o" # revert numeral return result.replace( "unu leu", "un leu" ).replace( "unu ban", "un ban" ).replace( # if the romanian low text is 0, it is not usually printed separator + " zero bani", "" ) def to_year(self, val, suffix=None, longval=True): result = super(Num2Word_RO, self).to_year( val, longval=longval ) # for years we want the era negation e.g. B.C., in our case # it's î.Hr. or î.e.n if result.startswith(self.negword): result = result.replace(self.negword, "") suffix = "î.Hr." if not suffix else suffix if suffix: result = "".join([ result, " ", suffix ]) return result num2words-0.5.14/num2words/lang_RU.py000066400000000000000000000515321473005321200174050ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .utils import get_digits, splitbyx GENDER_PLURAL_INDEXES = { 'm': 0, 'masculine': 0, 'м': 0, 'мужской': 0, 'f': 1, 'feminine': 1, 'ж': 0, 'женский': 0, 'n': 2, 'neuter': 2, 'с': 0, 'средний': 0, 'p': 3, 'plural': 3 } CASE_INDEXES = { 'n': 0, 'nominative': 0, 'и': 0, 'именительный': 0, 'g': 1, 'genitive': 1, 'р': 1, 'родительный': 1, 'd': 2, 'dative': 2, 'д': 2, 'дательный': 2, 'a': 3, 'accusative': 3, 'в': 3, 'винительный': 3, 'i': 4, 'instrumental': 4, 'т': 4, 'творительный': 4, 'p': 5, 'prepositional': 5, 'п': 5, 'предложный': 5 } # Default values D_CASE = 'n' D_PLURAL = False D_GENDER = 'm' D_ANIMATE = True def get_num_element(cases_dict, num, **kwargs): return case_classifier_element(cases_dict[num], **kwargs) def case_classifier_element(classifier, case=D_CASE, plural=D_PLURAL, gender=D_GENDER, animate=D_ANIMATE): case = classifier[CASE_INDEXES[case]] if isinstance(case, str): return case if plural: gender = case[GENDER_PLURAL_INDEXES['plural']] else: gender = case[GENDER_PLURAL_INDEXES[gender]] if isinstance(gender, str): return gender if animate: return gender[0] return gender[1] # format: # {n : [case_1 .. case_5]} # case: text or [gender_1 .. gender_3 plural_4] # gender: text or [animate, inanimate] ONES = { 0: ['ноль', 'ноля', 'нолю', 'ноль', 'нолём', 'ноле'], 1: [['один', 'одна', 'одно', 'одни'], ['одного', 'одной', 'одного', 'одних'], ['одному', 'одной', 'одному', 'одним'], [['одного', 'один'], 'одну', 'одно', ['одних', 'одни']], ['одним', 'одной', 'одним', 'одними'], ['одном', 'одной', 'одном', 'одних']], 2: [['два', 'две', 'два', 'двое'], ['двух'] * 3 + ['двоих'], ['двум'] * 3 + ['двоим'], [['двух', 'два'], ['двух', 'две'], 'два', 'двоих'], ['двумя'] * 3 + ['двоими'], ['двух'] * 3 + ['двоих']], 3: [['три'] * 3 + ['трое'], ['трёх'] * 3 + ['троих'], ['трём'] * 3 + ['троим'], [['трёх', 'три'], ['трёх', 'три'], 'три', 'троих'], ['тремя'] * 3 + ['троими'], ['трёх'] * 3 + ['троих']], 4: [['четыре'] * 3 + ['четверо'], ['четырёх'] * 3 + ['четверых'], ['четырём'] * 3 + ['четверым'], [['четырёх', 'четыре'], ['четырёх', 'четыре'], 'четыре', 'четверых'], ['четырьмя'] * 3 + ['четверыми'], ['четырёх'] * 3 + ['четверых']], 5: ['пять', 'пяти', 'пяти', 'пять', 'пятью', 'пяти'], 6: ['шесть', 'шести', 'шести', 'шесть', 'шестью', 'шести'], 7: ['семь', 'семи', 'семи', 'семь', 'семью', 'семи'], 8: ['восемь', 'восьми', 'восьми', 'восемь', 'восемью', 'восьми'], 9: ['девять', 'девяти', 'девяти', 'девять', 'девятью', 'девяти'] } ONES_ORD_PREFIXES = {0: 'нулев', 1: 'перв', 2: 'втор', 4: 'четвёрт', 5: 'пят', 6: 'шест', 7: 'седьм', 8: 'восьм', 9: 'девят'} ONES_ORD_POSTFIXES_GROUPS = {0: 0, 1: 1, 2: 0, 4: 1, 5: 1, 6: 0, 7: 0, 8: 0, 9: 1} CASE_POSTFIXES = [[{0: 'ой', 1: 'ый'}, 'ая', 'ое', 'ые'], ['ого', 'ой', 'ого', 'ых'], ['ому', 'ой', 'ому', 'ым'], [['ого', {0: 'ой', 1: 'ый'}], 'ую', 'ое', ['ых', 'ые']], ['ым', 'ой', 'ым', 'ыми'], ['ом', 'ой', 'ом', 'ых']] def get_cases(prefix, post_group): return [[ prefix + postfix if isinstance(postfix, str) else [prefix + animate if isinstance(animate, str) else prefix + animate[post_group] for animate in postfix] if isinstance(postfix, list) else prefix + postfix[post_group] for postfix in case] for case in CASE_POSTFIXES] def get_ord_classifier(prefixes, post_groups): if isinstance(post_groups, int): post_groups = {n: post_groups for n, i in prefixes.items()} return { num: get_cases(prefix, post_groups[num]) for num, prefix in prefixes.items() } ONES_ORD = { 3: [['третий', 'третья', 'третье', 'третьи'], ['третьего', 'третьей', 'третьего', 'третьих'], ['третьему', 'третьей', 'третьему', 'третьим'], [['третьего', 'третий'], 'третью', 'третье', ['третьих', 'третьи']], ['третьим', 'третьей', 'третьим', 'третьими'], ['третьем', 'третьей', 'третьем', 'третьих']], } ONES_ORD.update( get_ord_classifier(ONES_ORD_PREFIXES, ONES_ORD_POSTFIXES_GROUPS) ) TENS_PREFIXES = {1: 'один', 2: 'две', 3: 'три', 4: 'четыр', 5: 'пят', 6: 'шест', 7: 'сем', 8: 'восем', 9: 'девят'} TENS_POSTFIXES = ['надцать', 'надцати', 'надцати', 'надцать', 'надцатью', 'надцати'] TENS = {0: ['десять', 'десяти', 'десяти', 'десять', 'десятью', 'десяти']} TENS.update({ num: [prefix + postfix for postfix in TENS_POSTFIXES] for num, prefix in TENS_PREFIXES.items() }) TENS_ORD_PREFIXES = {0: "десят"} TENS_ORD_PREFIXES.update({ num: prefix + 'надцат' for num, prefix in TENS_PREFIXES.items() }) TENS_ORD = get_ord_classifier(TENS_ORD_PREFIXES, 1) TWENTIES = { 2: ['двадцать', 'двадцати', 'двадцати', 'двадцать', 'двадцатью', 'двадцати'], 3: ['тридцать', 'тридцати', 'тридцати', 'тридцать', 'тридцатью', 'тридцати'], 4: ['сорок', 'сорока', 'сорока', 'сорок', 'сорока', 'сорока'], 5: ['пятьдесят', 'пятидесяти', 'пятидесяти', 'пятьдесят', 'пятьюдесятью', 'пятидесяти'], 6: ['шестьдесят', 'шестидесяти', 'шестидесяти', 'шестьдесят', 'шестьюдесятью', 'шестидесяти'], 7: ['семьдесят', 'семидесяти', 'семидесяти', 'семьдесят', 'семьюдесятью', 'семидесяти'], 8: ['восемьдесят', 'восьмидесяти', 'восьмидесяти', 'восемьдесят', 'восемьюдесятью', 'восьмидесяти'], 9: ['девяносто', 'девяноста', 'девяноста', 'девяносто', 'девяноста', 'девяноста'], } TWENTIES_ORD_PREFIXES = {2: 'двадцат', 3: 'тридцат', 4: 'сороков', 5: 'пятидесят', 6: 'шестидесят', 7: 'семидесят', 8: 'восьмидесят', 9: 'девяност'} TWENTIES_ORD_POSTFIXES_GROUPS = {2: 1, 3: 1, 4: 0, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1} TWENTIES_ORD = get_ord_classifier(TWENTIES_ORD_PREFIXES, TWENTIES_ORD_POSTFIXES_GROUPS) HUNDREDS = { 1: ['сто', 'ста', 'ста', 'сто', 'ста', 'ста'], 2: ['двести', 'двухсот', 'двумстам', 'двести', 'двумястами', 'двухстах'], 3: ['триста', 'трёхсот', 'трёмстам', 'триста', 'тремястами', 'трёхстах'], 4: ['четыреста', 'четырёхсот', 'четырёмстам', 'четыреста', 'четырьмястами', 'четырёхстах'], 5: ['пятьсот', 'пятисот', 'пятистам', 'пятьсот', 'пятьюстами', 'пятистах'], 6: ['шестьсот', 'шестисот', 'шестистам', 'шестьсот', 'шестьюстами', 'шестистах'], 7: ['семьсот', 'семисот', 'семистам', 'семьсот', 'семьюстами', 'семистах'], 8: ['восемьсот', 'восьмисот', 'восьмистам', 'восемьсот', 'восемьюстами', 'восьмистах'], 9: ['девятьсот', 'девятисот', 'девятистам', 'девятьсот', 'девятьюстами', 'девятистах'], } HUNDREDS_ORD_PREFIXES = { num: case[1] if num != 1 else 'сот' for num, case in HUNDREDS.items() } HUNDREDS_ORD = get_ord_classifier(HUNDREDS_ORD_PREFIXES, 1) THOUSANDS_PREFIXES = {2: 'миллион', 3: 'миллиард', 4: 'триллион', 5: 'квадриллион', 6: 'квинтиллион', 7: 'секстиллион', 8: 'септиллион', 9: 'октиллион', 10: 'нониллион'} THOUSANDS_POSTFIXES = [('', 'а', 'ов'), ('а', 'ов', 'ов'), ('у', 'ам', 'ам'), ('', 'а', 'ов'), ('ом', 'ами', 'ами'), ('е', 'ах', 'ах')] THOUSANDS = { 1: [['тысяча', 'тысячи', 'тысяч'], ['тысячи', 'тысяч', 'тысяч'], ['тысяче', 'тысячам', 'тысячам'], ['тысячу', 'тысячи', 'тысяч'], ['тысячей', 'тысячами', 'тысячами'], ['тысяче', 'тысячах', 'тысячах']] } THOUSANDS.update({ num: [ [prefix + postfix for postfix in case] for case in THOUSANDS_POSTFIXES ] for num, prefix in THOUSANDS_PREFIXES.items() }) def get_thousands_elements(num, case): return THOUSANDS[num][CASE_INDEXES[case]] THOUSANDS_ORD_PREFIXES = {1: 'тысячн'} THOUSANDS_ORD_PREFIXES.update({ num: prefix + 'н' for num, prefix in THOUSANDS_PREFIXES.items() }) THOUSANDS_ORD = get_ord_classifier(THOUSANDS_ORD_PREFIXES, 1) class Num2Word_RU(Num2Word_Base): CURRENCY_FORMS = { 'RUB': ( ('рубль', 'рубля', 'рублей'), ('копейка', 'копейки', 'копеек') ), 'EUR': ( ('евро', 'евро', 'евро'), ('цент', 'цента', 'центов') ), 'USD': ( ('доллар', 'доллара', 'долларов'), ('цент', 'цента', 'центов') ), 'UAH': ( ('гривна', 'гривны', 'гривен'), ('копейка', 'копейки', 'копеек') ), 'KZT': ( ('тенге', 'тенге', 'тенге'), ('тиын', 'тиына', 'тиынов') ), 'BYN': ( ('белорусский рубль', 'белорусских рубля', 'белорусских рублей'), ('копейка', 'копейки', 'копеек') ), 'UZS': ( ('сум', 'сума', 'сумов'), ('тийин', 'тийина', 'тийинов') ), 'PLN': ( ('польский злотый', 'польских слотых', 'польских злотых'), ('грош', 'гроша', 'грошей') ), } def setup(self): self.negword = "минус" self.pointword = ('целая', 'целых', 'целых') self.pointword_ord = get_cases("цел", 1) def to_cardinal(self, number, case=D_CASE, plural=D_PLURAL, gender=D_GENDER, animate=D_ANIMATE): n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') decimal_part = self._int2word(int(right), cardinal=True, gender='f') return u'%s %s %s %s' % ( self._int2word(int(left), cardinal=True, gender='f'), self.pluralize(int(left), self.pointword), decimal_part, self.__decimal_bitness(right) ) else: return self._int2word(int(n), cardinal=True, case=case, plural=plural, gender=gender, animate=animate) def __decimal_bitness(self, n): if n[-1] == "1" and n[-2:] != "11": return self._int2word(10 ** len(n), cardinal=False, gender='f') return self._int2word(10 ** len(n), cardinal=False, case='g', plural=True) def pluralize(self, n, forms): if n % 100 in (11, 12, 13, 14): return forms[2] if n % 10 == 1: return forms[0] if n % 10 in (2, 3, 4): return forms[1] return forms[2] def to_ordinal(self, number, case=D_CASE, plural=D_PLURAL, gender=D_GENDER, animate=D_ANIMATE): self.verify_ordinal(number) n = str(number).replace(',', '.') return self._int2word(int(n), cardinal=False, case=case, plural=plural, gender=gender, animate=animate) def _money_verbose(self, number, currency): if currency == 'UAH': return self._int2word(number, gender='f') return self._int2word(number, gender='m') def _cents_verbose(self, number, currency): if currency in ('UAH', 'RUB', 'BYN'): return self._int2word(number, gender='f') return self._int2word(number, gender='m') def _int2word(self, n, feminine=False, cardinal=True, case=D_CASE, plural=D_PLURAL, gender=D_GENDER, animate=D_ANIMATE): """ n: number feminine: not used - for backward compatibility cardinal:True - cardinal False - ordinal case: 'n' - nominative 'g' - genitive 'd' - dative 'a' - accusative 'i' - instrumental 'p' - prepositional plural: True - plural False - singular gender: 'f' - masculine 'm' - feminine 'n' - neuter animate: True - animate False - inanimate """ # For backward compatibility if feminine: gender = 'f' kwargs = {'case': case, 'plural': plural, 'gender': gender, 'animate': animate} if n < 0: return ' '.join([self.negword, self._int2word(abs(n), cardinal=cardinal, **kwargs)]) if n == 0: return get_num_element(ONES, 0, **kwargs) if cardinal else \ get_num_element(ONES_ORD, 0, **kwargs) words = [] chunks = list(splitbyx(str(n), 3)) ord_join = chunks[-1] == 0 # join in one word if ending on 'тысячный' i = len(chunks) rightest_nonzero_chunk_i = i - 1 - max( [i for i, e in enumerate(chunks) if e != 0]) for x in chunks: chunk_words = [] i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if cardinal: chunk_words.extend( self.__chunk_cardianl(n3, n2, n1, i, **kwargs) ) if i > 0: chunk_words.append( self.pluralize(x, get_thousands_elements(i, case))) # ordinal, not joined like 'двухтысячный' elif not (ord_join and rightest_nonzero_chunk_i == i): chunk_words.extend( self.__chunk_ordinal(n3, n2, n1, i, **kwargs) ) if i > 0: t_case = case if rightest_nonzero_chunk_i == i else 'n' chunk_words.append( self.pluralize(x, get_thousands_elements(i, t_case))) # ordinal, joined else: chunk_words.extend( self.__chunk_ordinal_join(n3, n2, n1, i, **kwargs) ) if i > 0: chunk_words.append( get_num_element(THOUSANDS_ORD, i, **kwargs)) chunk_words = [''.join(chunk_words)] words.extend(chunk_words) return ' '.join(words) def __chunk_cardianl(self, hundreds, tens, ones, chunk_num, **kwargs): words = [] if hundreds > 0: words.append(get_num_element(HUNDREDS, hundreds, **kwargs)) if tens > 1: words.append(get_num_element(TWENTIES, tens, **kwargs)) if tens == 1: words.append(get_num_element(TENS, ones, **kwargs)) elif ones > 0: if chunk_num == 0: w_ones = get_num_element(ONES, ones, **kwargs) elif chunk_num == 1: # Thousands are feminine f_kwargs = kwargs.copy() f_kwargs['gender'] = 'f' w_ones = get_num_element(ONES, ones, **f_kwargs) else: w_ones = get_num_element(ONES, ones, **kwargs) words.append(w_ones) return words def __chunk_ordinal(self, hundreds, tens, ones, chunk_num, **kwargs): words = [] if hundreds > 0: if tens == 0 and ones == 0: words.append(get_num_element(HUNDREDS_ORD, hundreds, **kwargs)) else: words.append(get_num_element(HUNDREDS, hundreds)) if tens > 1: if ones == 0: words.append(get_num_element(TWENTIES_ORD, tens, **kwargs)) else: words.append(get_num_element(TWENTIES, tens)) if tens == 1: words.append(get_num_element(TENS_ORD, ones, **kwargs)) elif ones > 0: if chunk_num == 0: w_ones = get_num_element(ONES_ORD, ones, **kwargs) # тысячный, миллионнный и т.д. elif chunk_num > 0 and ones == 1 and hundreds == 0 and tens == 0: w_ones = None elif chunk_num == 1: # Thousands are feminine w_ones = get_num_element(ONES, ones, gender='f') else: w_ones = get_num_element(ONES, ones) if w_ones: words.append(w_ones) return words def __chunk_ordinal_join(self, hundreds, tens, ones, chunk_num, **kwargs): words = [] if hundreds > 1: words.append(get_num_element(HUNDREDS, hundreds, case='g')) elif hundreds == 1: words.append(get_num_element(HUNDREDS, hundreds)) # стО, not стА if tens == 9: words.append(get_num_element(TWENTIES, tens)) # девяностО, not А elif tens > 1: words.append(get_num_element(TWENTIES, tens, case='g')) if tens == 1: words.append(get_num_element(TENS, ones, case='g')) elif ones > 0: if chunk_num == 0: w_ones = get_num_element(ONES_ORD, ones, **kwargs) # тысячный, миллионнный и т.д., двадцатиодномиллионный elif chunk_num > 0 and ones == 1 and tens != 1: if tens == 0 and hundreds == 0: w_ones = None else: w_ones = get_num_element(ONES, 1, gender='n') else: w_ones = get_num_element(ONES, ones, case='g') if w_ones: words.append(w_ones) return words num2words-0.5.14/num2words/lang_SK.py000066400000000000000000000110251473005321200173650ustar00rootroot00000000000000# -*- coding: utf-8 -*- # 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = ('nula',) ONES = { 1: ('jeden', 'jeden', set()), 2: ('dva', 'dve', {1, 3, 5, 7, 9}), 3: ('tri', 'tri', set()), 4: ('štyri', 'štyri', set()), 5: ('päť', 'päť', set()), 6: ('šesť', 'šesť', set()), 7: ('sedem', 'sedem', set()), 8: ('osem', 'osem', set()), 9: ('deväť', 'deväť', set()), } TENS = { 0: ('desať',), 1: ('jedenásť',), 2: ('dvanásť',), 3: ('trinásť',), 4: ('štrnásť',), 5: ('pätnásť',), 6: ('šestnásť',), 7: ('sedemnásť',), 8: ('osemnásť',), 9: ('devätnásť',), } TWENTIES = { 2: ('dvadsať',), 3: ('tridsať',), 4: ('štyridsať',), 5: ('päťdesiat',), 6: ('šesťdesiat',), 7: ('sedemdesiat',), 8: ('osemdesiat',), 9: ('deväťdesiat',), } HUNDREDS = { 1: ('sto',), 2: ('dvesto',), 3: ('tristo',), 4: ('štyristo',), 5: ('päťsto',), 6: ('šesťsto',), 7: ('sedemsto',), 8: ('osemsto',), 9: ('deväťsto',), } THOUSANDS = { 1: ('tisíc', 'tisíc', 'tisíc'), # 10^3 2: ('milión', 'milióny', 'miliónov'), # 10^6 3: ('miliarda', 'miliardy', 'miliárd'), # 10^9 4: ('bilión', 'bilióny', 'biliónov'), # 10^12 5: ('biliarda', 'biliardy', 'biliárd'), # 10^15 6: ('trilión', 'trilióny', 'triliónov'), # 10^18 7: ('triliarda', 'triliardy', 'triliárd'), # 10^21 8: ('kvadrilión', 'kvadrilióny', 'kvadriliónov'), # 10^24 9: ('kvadriliarda', 'kvadriliardy', 'kvadriliárd'), # 10^27 10: ('kvintilión', 'kvintillióny', 'kvintiliónov'), # 10^30 } class Num2Word_SK(Num2Word_Base): CURRENCY_FORMS = { 'EUR': ( ('euro', 'eurá', 'eur'), ('cent', 'centy', 'centov') ), } def setup(self): self.negword = "mínus" self.pointword = "celých" def to_cardinal(self, number): n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + self._int2word(int(right))) return u'%s %s %s' % ( self._int2word(int(left)), self.pointword, decimal_part ) else: return self._int2word(int(n)) def pluralize(self, n, forms): if n == 1: form = 0 elif 0 < n < 5: form = 1 else: form = 2 return forms[form] def to_ordinal(self, value): raise NotImplementedError() def _int2word(self, n): if n == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) word_chunk = [] if n3 > 0: word_chunk.append(HUNDREDS[n3][0]) if n2 > 1: word_chunk.append(TWENTIES[n2][0]) if n2 == 1: word_chunk.append(TENS[n1][0]) elif n1 > 0 and not (i > 0 and x == 1): if n2 == 0 and n3 == 0 and i in ONES[n1][2]: word_chunk.append(ONES[n1][1]) else: word_chunk.append(ONES[n1][0]) if i > 1 and word_chunk: word_chunk.append(' ') if i > 0: word_chunk.append(self.pluralize(x, THOUSANDS[i])) words.append(''.join(word_chunk)) return ' '.join(words[:-1]) + ''.join(words[-1:]) num2words-0.5.14/num2words/lang_SL.py000066400000000000000000000142621473005321200173740ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2015, Blaz Bregar. 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_EU import Num2Word_EU class Num2Word_SL(Num2Word_EU): GIGA_SUFFIX = "ilijard" MEGA_SUFFIX = "ilijon" def setup(self): super(Num2Word_SL, self).setup() self.negword = "minus " self.pointword = "celih" self.errmsg_nonnum = "Only numbers may be converted to words." self.errmsg_toobig = ( "Number is too large to convert to words (abs(%s) > %s)." ) self.exclude_title = [] self.mid_numwords = [(1000, "tisoč"), (900, "devetsto"), (800, "osemsto"), (700, "sedemsto"), (600, "šeststo"), (500, "petsto"), (400, "štiristo"), (300, "tristo"), (200, "dvesto"), (100, "sto"), (90, "devetdeset"), (80, "osemdeset"), (70, "sedemdeset"), (60, "šestdeset"), (50, "petdeset"), (40, "štirideset"), (30, "trideset")] self.low_numwords = ["dvajset", "devetnajst", "osemnajst", "sedemnajst", "šestnajst", "petnajst", "štirinajst", "trinajst", "dvanajst", "enajst", "deset", "devet", "osem", "sedem", "šest", "pet", "štiri", "tri", "dve", "ena", "nič"] self.ords = {"ena": "prv", "dve": "drug", "tri": "tretj", "štiri": "četrt", "sedem": "sedm", "osem": "osm", "sto": "stot", "tisoč": "tisoč", "milijon": "milijont" } self.ordflag = False def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if ctext.endswith("dve") and self.ordflag and nnum <= 1000000: ctext = ctext[:len(ctext)-1] + "a" if ctext == "dve" and not self.ordflag and nnum < 1000000000: ctext = "dva" if (ctext.endswith("tri") or ctext.endswith("štiri")) and\ nnum == 1000000 and not self.ordflag: if ctext.endswith("štiri"): ctext = ctext[:-1] ctext = ctext + "je" if cnum >= 20 and cnum < 100 and nnum == 2: ntext = "dva" if ctext.endswith("ena") and nnum >= 1000: ctext = ctext[0:-1] if cnum == 1: if nnum < 10**6 or self.ordflag: return next ctext = "" if nnum > cnum: if nnum >= 10**6: if self.ordflag: ntext += "t" elif cnum == 2: if ntext.endswith("d"): ntext += "i" else: ntext += "a" elif 2 < cnum < 5: if ntext.endswith("d"): ntext += "e" elif not ntext.endswith("d"): ntext += "i" elif ctext.endswith("en"): if ntext.endswith("d") or ntext.endswith("n"): ntext += "" elif ctext.endswith("dve") and ntext.endswith("n"): ctext = ctext[:-1] + "a" ntext += "a" elif ctext.endswith("je") and ntext.endswith("n"): ntext += "i" else: if ntext.endswith("d"): ntext += "a" elif ntext.endswith("n"): ntext += "" elif ntext.endswith("d"): ntext += "e" else: ntext += "ov" if nnum >= 10**2 and self.ordflag is False and ctext: ctext += " " val = cnum * nnum else: if nnum < 10 < cnum < 100: ntext, ctext = ctext, ntext + "in" elif cnum >= 10**2 and self.ordflag is False: ctext += " " val = cnum + nnum word = ctext + ntext return (word, val) def to_ordinal(self, value): self.verify_ordinal(value) self.ordflag = True outword = self.to_cardinal(value) self.ordflag = False for key in self.ords: if outword.endswith(key): outword = outword[:len(outword) - len(key)] + self.ords[key] break return outword + "i" # Is this correct?? def to_ordinal_num(self, value): self.verify_ordinal(value) return str(value) + "." def to_currency(self, val, longval=True, old=False): if old: return self.to_splitnum(val, hightxt="evro/a/v", lowtxt="stotin/a/i/ov", jointxt="in", longval=longval) return super(Num2Word_SL, self).to_currency(val, jointxt="in", longval=longval) def to_year(self, val, longval=True): if not (val//100) % 10: return self.to_cardinal(val) return self.to_splitnum(val, hightxt="hundert", longval=longval) num2words-0.5.14/num2words/lang_SR.py000066400000000000000000000150411473005321200173760ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .currency import parse_currency_parts, prefix_currency from .utils import get_digits, splitbyx ZERO = ('nula',) ONES = { 1: ('jedan', 'jedna'), 2: ('dva', 'dve'), 3: ('tri', 'tri'), 4: ('četiri', 'četiri'), 5: ('pet', 'pet'), 6: ('šest', 'šest'), 7: ('sedam', 'sedam'), 8: ('osam', 'osam'), 9: ('devet', 'devet'), } TENS = { 0: ('deset',), 1: ('jedanaest',), 2: ('dvanaest',), 3: ('trinaest',), 4: ('četrnaest',), 5: ('petnaest',), 6: ('šesnaest',), 7: ('sedamnaest',), 8: ('osamnaest',), 9: ('devetnaest',), } TWENTIES = { 2: ('dvadeset',), 3: ('trideset',), 4: ('četrdeset',), 5: ('pedeset',), 6: ('šezdeset',), 7: ('sedamdeset',), 8: ('osamdeset',), 9: ('devedeset',), } HUNDREDS = { 1: ('sto',), 2: ('dvesta',), 3: ('trista',), 4: ('četristo',), 5: ('petsto',), 6: ('šesto',), 7: ('sedamsto',), 8: ('osamsto',), 9: ('devetsto',), } SCALE = { 0: ('', '', '', False), 1: ('hiljada', 'hiljade', 'hiljada', True), # 10^3 2: ('milion', 'miliona', 'miliona', False), # 10^6 3: ('bilion', 'biliona', 'biliona', False), # 10^9 4: ('trilion', 'triliona', 'triliona', False), # 10^12 5: ('kvadrilion', 'kvadriliona', 'kvadriliona', False), # 10^15 6: ('kvintilion', 'kvintiliona', 'kvintiliona', False), # 10^18 7: ('sekstilion', 'sekstiliona', 'sekstiliona', False), # 10^21 8: ('septilion', 'septiliona', 'septiliona', False), # 10^24 9: ('oktilion', 'oktiliona', 'oktiliona', False), # 10^27 10: ('nonilion', 'noniliona', 'noniliona', False), # 10^30 } class Num2Word_SR(Num2Word_Base): CURRENCY_FORMS = { 'RUB': ( ('rublja', 'rublje', 'rublji', True), ('kopejka', 'kopejke', 'kopejki', True) ), 'EUR': ( ('evro', 'evra', 'evra', False), ('cent', 'centa', 'centi', False) ), 'RSD': ( ('dinar', 'dinara', 'dinara', False), ('para', 'pare', 'para', True) ), } def setup(self): self.negword = "minus" self.pointword = "zapeta" def to_cardinal(self, number, feminine=False): n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + self._int2word(int(right), feminine)) return u'%s %s %s' % ( self._int2word(int(left), feminine), self.pointword, decimal_part ) else: return self._int2word(int(n), feminine) def pluralize(self, number, forms): if number % 100 < 10 or number % 100 > 20: if number % 10 == 1: form = 0 elif 1 < number % 10 < 5: form = 1 else: form = 2 else: form = 2 return forms[form] def to_ordinal(self, number): raise NotImplementedError() def _cents_verbose(self, number, currency): return self._int2word( number, self.CURRENCY_FORMS[currency][1][-1] ) def _int2word(self, number, feminine=False): if number < 0: return ' '.join([self.negword, self._int2word(abs(number))]) if number == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(number), 3)) chunk_len = len(chunks) for chunk in chunks: chunk_len -= 1 digit_right, digit_mid, digit_left = get_digits(chunk) if digit_left > 0: words.append(HUNDREDS[digit_left][0]) if digit_mid > 1: words.append(TWENTIES[digit_mid][0]) if digit_mid == 1: words.append(TENS[digit_right][0]) elif digit_right > 0: is_feminine = feminine or SCALE[chunk_len][-1] gender_idx = int(is_feminine) words.append( ONES[digit_right][gender_idx] ) if chunk_len > 0 and chunk != 0: words.append(self.pluralize(chunk, SCALE[chunk_len])) return ' '.join(words) def to_currency(self, val, currency='EUR', cents=True, separator=',', adjective=False): """ Args: val: Numeric value currency (str): Currency code cents (bool): Verbose cents separator (str): Cent separator adjective (bool): Prefix currency name with adjective Returns: str: Formatted string """ left, right, is_negative = parse_currency_parts(val) 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 if is_negative else "" cents_str = self._cents_verbose(right, currency) \ if cents else self._cents_terse(right, currency) return u'%s%s %s%s %s %s' % ( minus_str, self.to_cardinal(left, feminine=cr1[-1]), self.pluralize(left, cr1), separator, cents_str, self.pluralize(right, cr2) ) num2words-0.5.14/num2words/lang_SV.py000066400000000000000000000110211473005321200173740ustar00rootroot00000000000000# -*- 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_EU class Num2Word_SV(lang_EU.Num2Word_EU): GIGA_SUFFIX = "iljarder" MEGA_SUFFIX = "iljoner" 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 setup(self): super(Num2Word_SV, self).setup() self.negword = "minus " self.pointword = "komma" self.exclude_title = ["och", "komma", "minus"] self.mid_numwords = [(1000, "tusen"), (100, "hundra"), (90, "nittio"), (80, "åttio"), (70, "sjuttio"), (60, "sextio"), (50, "femtio"), (40, "förtio"), (30, "trettio")] self.low_numwords = ["tjugo", "nitton", "arton", "sjutton", "sexton", "femton", "fjorton", "tretton", "tolv", "elva", "tio", "nio", "åtta", "sju", "sex", "fem", "fyra", "tre", "två", "ett", "noll"] self.ords = {"noll": "nollte", "ett": "första", "två": "andra", "tre": "tredje", "fyra": "fjärde", "fem": "femte", "sex": "sjätte", "sju": "sjunde", "åtta": "åttonde", "nio": "nionde", "tio": "tionde", "elva": "elfte", "tolv": "tolfte", "tjugo": "tjugonde"} 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%s" % (ltext, rtext), lnum + rnum) elif rnum >= 1000000 and lnum == 1: return ("%s %s" % ('en', rtext[:-2]), lnum + rnum) elif rnum >= 1000000 and lnum > 1: return ("%s %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(" ") lastword = outwords[-1] ending_length = 0 try: lastword_ending = self.ords[lastword[-4:]] ending_length = 4 except KeyError: try: lastword_ending = self.ords[lastword[-3:]] ending_length = 3 except KeyError: lastword_ending = "de" if lastword_ending == 'de': lastword_first_part = self.title(lastword)[:] else: lastword_first_part = self.title(lastword)[:-ending_length] lastword_correct = lastword_first_part + lastword_ending outwords[-1] = lastword_correct return " ".join(outwords) def to_ordinal_num(self, value): raise NotImplementedError( "'ordinal_num' is not implemented for swedish language") def to_year(self, val, longval=True): raise NotImplementedError( "'year' is not implemented for swedish language") def to_currency(self, val, longval=True): raise NotImplementedError( "'currency' is not implemented for swedish language") num2words-0.5.14/num2words/lang_TE.py000066400000000000000000000143661473005321200173730ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import unicode_literals from .lang_EU import Num2Word_EU class Num2Word_TE(Num2Word_EU): def set_high_numwords(self, high): for n, word in self.high_numwords: self.cards[10**n] = word def setup(self): self.low_numwords = [ "తొంభై తొమ్మిది", "తొంభై ఎనిమిది", "తొంభై ఏడు", "తొంభై ఆరు", "తొంభై అయిదు", "తొంభై నాలుగు", "తొంభై మూడు", "తొంభై రెండు", "తొంభై ఒకటి", "తొంభై", "ఎనభై తొమ్మిది", "ఎనభై ఎనిమిది", "ఎనభై ఏడు", "ఎనభై ఆరు", "ఎనభై అయిదు", "ఎనభై నాలుగు", "ఎనభై మూడు", "ఎనభై రెండు", "ఎనభై ఒకటి", "ఎనభై", "డెబ్బై తొమ్మిది", "డెబ్బై ఎనిమిది", "డెబ్బై ఏడు", "డెబ్బై ఆరు", "డెబ్బై అయిదు", "డెబ్బై నాలుగు", "డెబ్బై మూడు", "డెబ్బై రెండు", "డెబ్బై ఒకటి", "డెబ్బై", "అరవై తొమ్మిది", "అరవై ఎనిమిది", "అరవై ఏడు", "అరవై ఆరు", "అరవై అయిదు", "అరవై నాలుగు", "అరవై మూడు", "అరవై రెండు", "అరవై ఒకటి", "అరవై", "యాభై తొమ్మిది", "యాభై ఎనిమిది", "యాభై ఏడు", "యాభై ఆరు", "యాభై అయిదు", "యాభై నాలుగు", "యాభై మూడు", "యాభై రెండు", "యాభై ఒకటి", "యాభై ", "నలభై తొమ్మిది", "నలభై ఎనిమిది", "నలభై ఏడు", "నలభై ఆరు", "నలభై అయిదు", "నలభై నాలుగు", "నలభై మూడు", "నలభై రెండు", "నలభై ఒకటి", "నలభై", "ముప్పై తొమ్మిది", "ముప్పై ఎనిమిది", "ముప్పై ఏడు", "ముప్పై ఆరు", "ముప్పై ఐదు", "ముప్పై నాలుగు", "ముప్పై మూడు", "ముప్పై రెండు", "ముప్పై ఒకటి", "ముప్పై", "ఇరవై తొమ్మిది", "ఇరవై ఎనిమిది", "ఇరవై ఏడు", "ఇరవై ఆరు", "ఇరవై అయిదు", "ఇరవై నాలుగు", "ఇరవై మూడు", "ఇరవై రెండు", "ఇరవై ఒకటి", "ఇరవై", "పందొమ్మిది", "పధ్ధెనిమిది", "పదిహేడు", "పదహారు", "పదునయిదు", "పధ్నాలుగు", "పదమూడు", "పన్నెండు", "పదకొండు", "పది", "తొమ్మిది", "ఎనిమిది", "ఏడు", "ఆరు", "అయిదు", "నాలుగు", "మూడు", "రెండు", "ఒకటి", "సున్న", ] self.mid_numwords = [(100, "వంద")] self.high_numwords = [(7, "కోట్ల"), (5, "లక్ష"), (3, "వేయి")] self.pointword = "బిందువు " self.modifiers = [ " ్ ", "ా ", " ి ", " ీ ", " ు ", " ూ ", " ృ ", " ౄ ", " ె ", " ే ", " ై ", " ొ", " ో ", " ౌ ", " ఁ ", " ం ", " ః ", ] 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: if ltext[-1] in self.modifiers: return ("%s %s" % (ltext[:-1], rtext), lnum + rnum) else: return ("%s %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_num(self, value): self.verify_ordinal(value) return "%s%s" % (value, self.to_ordinal(value)[-1:]) def to_ordinal(self, value): self.verify_ordinal(value) outwords = self.to_cardinal(value) if outwords[-1] in self.modifiers: outwords = outwords[:-1] ordinal_num = outwords + "వ" return ordinal_num num2words-0.5.14/num2words/lang_TET.py000066400000000000000000000204371473005321200175130ustar00rootroot00000000000000# -*- coding: utf-8 -*-Num2Word_TET # 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 num2words.currency import parse_currency_parts from .lang_EU import Num2Word_EU DOLLAR = ('dolar', 'dolar') CENTS = ('sentavu', 'sentavu') class Num2Word_TET(Num2Word_EU): CURRENCY_FORMS = { 'AUD': (DOLLAR, CENTS), 'CAD': (DOLLAR, CENTS), 'EUR': (('euro', 'euros'), CENTS), 'GBP': (('pound sterling', 'pound sterling'), ('pence', 'pence')), 'USD': (DOLLAR, CENTS), } GIGA_SUFFIX = None MEGA_SUFFIX = "iliaun" def setup(self): super().setup() lows = ["kuatr", "tr", "b", "m"] self.high_numwords = self.gen_high_numwords([], [], lows) self.negword = "menus " self.pointword = "vírgula" self.exclude_title = ["resin", "vírgula", "menus"] self.count = 0 self.mid_numwords = [ (1000, "rihun"), (100, "atus"), (90, "sianulu"), (80, "ualunulu"), (70, "hitunulu"), (60, "neenulu"), (50, "limanulu"), (40, "haatnulu"), (30, "tolunulu"), (20, "ruanulu") ] self.low_numwords = [ "sanulu", "sia", "ualu", "hitu", "neen", "lima", "haat", "tolu", "rua", "ida", "mamuk" ] self.hundreds = { 1: "atus", 2: "atus rua", 3: "atus tolu", 4: "atus haat", 5: "atus lima", 6: "atus neen", 7: "atus hitu", 8: "atus ualu", 9: "atus sia", } def merge(self, curr, next): ctext, cnum, ntext, nnum = curr + next if cnum == 1 and nnum < 100: return next if nnum < cnum: if nnum < 10: value_str = str(cnum + nnum) if int(value_str) > 100: zero_list = value_str[1:-1] all_zero = all(element == '0' for element in zero_list) if all_zero: if self.count >= 1: self.count += 0 return ( "ho %s %s" % (ctext, ntext), cnum + nnum ) self.count += 1 return ("%s %s" % (ctext, ntext), cnum + nnum) return ("%s resin %s" % (ctext, ntext), cnum + nnum) else: return ("%s %s" % (ctext, ntext), cnum + nnum) return (ntext + " " + ctext, cnum * nnum) def ho_result(self, result, value): index = result.find('ho') count_ho = result.count('ho') if index != -1 and count_ho >= 1: index_rihun = result.find('rihun') value_str = len(str(value)) if index_rihun != -1 and value_str > 7: result = result.replace("rihun ho", "ho rihun") lows = ["kuatr", "tr", "b", "m"] MEGA_SUFFIX = "iliaun" for low in lows: result = result.replace( low + MEGA_SUFFIX + " ho", "ho " + low + MEGA_SUFFIX) remove_first_ho = result.startswith('ho') if remove_first_ho: result = result[3:] return result def remove_ho(self, result, value): value_str = str(value) result = self.ho_result(result, value) end_value = value_str[:-4] end_true = end_value.endswith('0') if end_true is False: if value > 100: if value_str[-1] != '0' and value_str[-2] == '0': result = result.replace("ho", "") result = result.replace(" ", " ") return result def to_cardinal(self, value): result = super().to_cardinal(value) results = self.remove_ho(result, value) return results def to_ordinal(self, value): self.verify_ordinal(value) out = "" val = self.splitnum(value) outs = val while len(val) != 1: outs = [] left, right = val[:2] if isinstance(left, tuple) and isinstance(right, tuple): outs.append(self.merge(left, right)) if val[2:]: outs.append(val[2:]) else: for elem in val: if isinstance(elem, list): if len(elem) == 1: outs.append(elem[0]) else: outs.append(self.clean(elem)) else: outs.append(elem) val = outs words, num = outs[0] words = self.remove_ho(words, value) if num in [90, 80, 70, 60, 50, 40, 30, 20, 10, 9, 8, 7, 5, 3, 2]: words = 'da'+words+'k' if num in [6, 4]: words = 'da'+words if num == 1: words = 'dahuluk' if num in [900, 800, 700, 500, 300, 200, 100]: words = 'dah'+words+'k' if num in [600, 400]: words = 'dah'+words words_split = words.split() if len(words_split) >= 3 and num < 100: first_word = 'da'+words_split[0] second_word = " ".join(words_split[1:]) if 'haat' in second_word or 'neen' in second_word: words = first_word+" "+second_word else: words = first_word+" "+second_word+'k' word_first = 'dah'+words_split[0] if word_first == 'dahatus' and len(words_split) >= 3: word_second = " ".join(words_split[1:]) if 'haat' in word_second or 'neen' in word_second: words = word_first+" "+word_second else: words = word_first+" "+word_second+'k' if len(str(num)) > 3: if 'haat' in words_split[-1:] or 'neen' in words_split[-1:]: words = 'da'+words else: words = 'da'+words+'k' result = self.title(out + words) return result def to_ordinal_num(self, value): self.verify_ordinal(value) return "%sº" % (value) def to_year(self, val, longval=True): if val < 0: return self.to_cardinal(abs(val)) + ' antes Kristu' return self.to_cardinal(val) def to_currency(self, val, currency='USD', cents=True): """ Args: val: Numeric value currency (str): Currency code cents (bool): Verbose cents adjective (bool): Prefix currency name with adjective Returns: str: Formatted string """ left, right, is_negative = parse_currency_parts(val) try: cr1, cr2 = self.CURRENCY_FORMS[currency] except KeyError: raise NotImplementedError( 'Currency code "%s" not implemented for "%s"' % (currency, self.__class__.__name__)) minus_str = "%s " % self.negword.strip() if is_negative else "" money_str = self._money_verbose(left, currency) cents_str = self._cents_verbose(right, currency) \ if cents else self._cents_terse(right, currency) if right == 0: return u'%s%s %s' % ( minus_str, self.pluralize(left, cr1), money_str ) else: return u'%s%s %s %s %s' % ( minus_str, self.pluralize(left, cr1), money_str, self.pluralize(right, cr2), cents_str ) num2words-0.5.14/num2words/lang_TG.py000066400000000000000000000117241473005321200173700ustar00rootroot00000000000000# -*- 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_EU GENERIC_DOLLARS = ("доллар", "доллар") GENERIC_CENTS = ("сент", "сент") class Num2Word_TG(lang_EU.Num2Word_EU): CURRENCY_FORMS = { # repalced by EUR "EUR": (("евро", "евро"), GENERIC_CENTS), # replaced by EUR "USD": (GENERIC_DOLLARS, GENERIC_CENTS), "RUB": (("рубл", "рубл"), ("копейк", "копейк")), "TJS": (("сомонӣ", "сомонӣ"), ("дирам", "дирам")), } GIGA_SUFFIX = "иллиард" MEGA_SUFFIX = "иллион" def set_high_numwords(self, high): cap = 3 * (len(high) + 1) for word, n in zip(high, range(cap, 5, -3)): if n == 9: self.cards[10 ** n] = word + self.GIGA_SUFFIX else: self.cards[10 ** n] = word + self.MEGA_SUFFIX def setup(self): super(Num2Word_TG, self).setup() lows = ["квинт", "квадр", "тр", "м", "м"] self.high_numwords = self.gen_high_numwords([], [], lows) self.negword = "минус " self.pointword = "нуқта" self.exclude_title = ["ва", "минус", "нуқта"] self.mid_numwords = [ (1000, "ҳазор"), (100, "сад"), (90, "навад"), (80, "ҳаштод"), (70, "ҳафтод"), (60, "шаст"), (50, "панҷоҳ"), (40, "чил"), (30, "си"), ] self.low_numwords = [ "бист", "нуздаҳ", "ҳаждаҳ", "ҳабдаҳ", "шонздаҳ", "понздаҳ", "чордаҳ", "сенздаҳ", "дувоздаҳ", "ёздаҳ", "даҳ", "нӯҳ", "ҳашт", "ҳафт", "шаш", "панҷ", "чор", "се", "ду", "як", "сифр", ] def to_cardinal(self, value): try: assert int(value) == value except (ValueError, TypeError, AssertionError): return self.to_cardinal_float(value) out = "" if value < 0: value = abs(value) out = self.negword if value >= self.MAXVAL: raise OverflowError(self.errmsg_toobig % (value, self.MAXVAL)) if value == 100: return self.title(out + "сад") else: val = self.splitnum(value) words, num = self.clean(val) return self.title(out + words) def merge(self, lpair, rpair): ltext, lnum = lpair rtext, rnum = rpair if lnum == 1 and rnum < 100: return (rtext, rnum) elif 100 > lnum > rnum: if ltext == "си": return ("%sю %s" % (ltext, rtext), lnum + rnum) elif ltext == "панҷоҳ": return ("панҷову %s" % (rtext), lnum + rnum) else: return ("%sу %s" % (ltext, rtext), lnum + rnum) elif lnum >= 100 > rnum: return ("%sу %s" % (ltext, rtext), lnum + rnum) elif rnum > lnum: if ltext == "яксад" and rtext not in self.low_numwords: return ("сад %s" % (rtext), lnum * rnum) if rtext == "сад": return ("%s%s" % (ltext, rtext), lnum * rnum) else: return ("%s %s" % (ltext, rtext), lnum * rnum) return ("%sу %s" % (ltext, rtext), lnum + rnum) def to_ordinal(self, value): self.verify_ordinal(value) cardinal = self.to_cardinal(value) outwords = cardinal.split(" ") lastword = outwords[-1] if lastword in ["ду", "се", "си"]: return "%sюм" % (cardinal) else: return "%sум" % (cardinal) def to_ordinal_num(self, value): self.verify_ordinal(value) return "%s%s" % (value, self.to_ordinal(value)[-2:]) num2words-0.5.14/num2words/lang_TH.py000066400000000000000000000132131473005321200173640ustar00rootroot00000000000000# -*- 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 num2words.base import Num2Word_Base from num2words.currency import parse_currency_parts from num2words.utils import splitbyx class Num2Word_TH(Num2Word_Base): def setup(self): self.negword = 'ติดลบ' self.pointword = 'จุด' self.CURRENCY_FORMS = { 'THB': (('บาท', 'บาท'), ('สตางค์', 'สตางค์')), 'USD': (('ดอลลาร์', 'ดอลลาร์'), ('เซนต์', 'เซนต์')), 'EUR': (('ยูโร', 'ยูโร'), ('เซนต์', 'เซนต์')), } self.high_numwords = [] self.mid_numwords = ['', 'สิบ', 'ร้อย', 'พัน', 'หมื่น', 'แสน', 'ล้าน'] self.low_numwords = [ 'ศูนย์', 'หนึ่ง', 'สอง', 'สาม', 'สี่', 'ห้า', 'หก', 'เจ็ด', 'แปด', 'เก้า' ] def set_high_numwords(self, high_numwords): pass def set_mid_numwords(self, mid_numwords): pass def splitnum(self, six_num): length = len(six_num) > 1 word_num = '' for index, num in enumerate(map(int, six_num)): if num: if index: word_num = self.mid_numwords[index] + word_num if length and num == 1 and index == 0: word_num += 'เอ็ด' elif index == 1 and num == 2: word_num = 'ยี่' + word_num elif index != 1 or num != 1: word_num = self.low_numwords[num] + word_num elif num == 0 and index == 0 and length == 0: word_num = self.low_numwords[0] return word_num def split_six(self, num_txt): result = splitbyx(num_txt, 6, format_int=False) result = list(result)[::-1] number_list = [] for i in result: number_list.append(i[::-1]) return number_list def add_text_million(self, word_num): result = '' for index, t in enumerate(reversed(word_num)): if index == 0: result = t else: result = result + 'ล้าน' + t return result def round_2_decimal(self, number): integer, cents, negative = parse_currency_parts( number, is_int_with_cents=False ) integer = '{}'.format(integer) cents = '{}'.format(cents) if len(cents) < 2: add_zero = 2 - len(cents) cents = ('0' * add_zero) + cents text_num = integer + '.' + cents return text_num, negative def left_num_to_text(self, number): left_num_list = self.split_six(number) left_text_list = [] for i in left_num_list: left_text_list.append(self.splitnum(i)) left_text = self.add_text_million(left_text_list) return left_text def to_cardinal(self, number): negative = number < 0 pre, post = self.float2tuple(number) precision = self.precision pre = '{}'.format(pre) post = '{}'.format(post) if negative: pre = pre.lstrip('-') if len(post) < precision: add_zero = precision - len(post) post = ('0' * add_zero) + post result = self.left_num_to_text(pre) right_text = '' if not post == '0': for i in map(int, post): right_text = right_text + self.low_numwords[i] result = result + 'จุด' + right_text if negative: result = 'ติดลบ' + result return result def to_ordinal(self, number): return self.to_cardinal(number) def to_currency(self, number, currency='THB'): number, negative = self.round_2_decimal(number) split_num = number.split('.') left_num = split_num[0] left_text = self.left_num_to_text(left_num) right_num = split_num[1] right_text = self.splitnum(right_num[::-1].rstrip('0')) try: cr1, cr2 = self.CURRENCY_FORMS[currency] except KeyError: raise NotImplementedError( 'Currency code "%s" not implemented for "%s"' % (currency, self.__class__.__name__)) if right_num == '00': if currency == 'THB': result = left_text + cr1[0] + 'ถ้วน' else: result = left_text + cr1[0] else: if left_num == '0': result = right_text + cr2[0] else: result = left_text + cr1[0] + right_text + cr2[0] if negative: result = self.negword + result return result num2words-0.5.14/num2words/lang_TR.py000066400000000000000000001163501473005321200174040ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2017, Tufan Kaynak, Framras. 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 .base import Num2Word_Base class Num2Word_TR(Num2Word_Base): def __init__(self): self.precision = 2 self.negword = u"eksi" self.pointword = u"virgül" self.CURRENCY_UNIT = u"lira" self.CURRENCY_SUBUNIT = u"kuruş" self.errmsg_nonnum = u"Sadece sayılar yazıya çevrilebilir." self.errmsg_floatord = u"Tam sayı olmayan {} sıralamada kullanılamaz." self.errmsg_negord = u"Pozitif olmayan {} sıralamada kullanılamaz." self.errmsg_toobig = u"abs({}) sayı yazıya çevirmek için çok büyük. " \ u"Yazıya çevrilebilecek en büyük rakam {}." self.exclude_title = [] self.DECIMAL_SIGN = "," self.ORDINAL_SIGN = "." self.ZERO = u"sıfır" self.CARDINAL_ONES = { "1": u"bir", "2": u"iki", "3": u"üç", "4": u"dört", "5": u"beş", "6": u"altı", "7": u"yedi", "8": u"sekiz", "9": u"dokuz" } self.ORDINAL_ONES = { "1": u"birinci", "2": u"ikinci", "3": u"üçüncü", "4": u"dördüncü", "5": u"beşinci", "6": u"altıncı", "7": u"yedinci", "8": u"sekizinci", "9": u"dokuzuncu" } self.CARDINAL_TENS = { "1": u"on", "2": u"yirmi", "3": u"otuz", "4": u"kırk", "5": u"elli", "6": u"altmış", "7": u"yetmiş", "8": u"seksen", "9": u"doksan" } self.ORDINAL_TENS = { "1": u"onuncu", "2": u"yirminci", "3": u"otuzuncu", "4": u"kırkıncı", "5": u"ellinci", "6": u"altmışıncı", "7": u"yetmişinci", "8": u"sekseninci", "9": u"doksanıncı" } self.HUNDREDS = { "2": u"iki", "3": u"üç", "4": u"dört", "5": u"beş", "6": u"altı", "7": u"yedi", "8": u"sekiz", "9": u"dokuz" } self.CARDINAL_HUNDRED = (u"yüz",) self.ORDINAL_HUNDRED = (u"yüzüncü",) self.CARDINAL_TRIPLETS = { 1: u"bin", 2: u"milyon", 3: u"milyar", 4: u"trilyon", 5: u"katrilyon", 6: u"kentilyon" } self.ORDINAL_TRIPLETS = { 1: u"bininci", 2: u"milyonuncu", 3: u"milyarıncı", 4: u"trilyonuncu", 5: u"katrilyonuncu", 6: u"kentilyon" } self.MAXVAL = (10 ** ((len(self.CARDINAL_TRIPLETS) + 1) * 3)) - 1 self.integers_to_read = [] self.total_triplets_to_read = 0 self.total_digits_outside_triplets = 0 self.order_of_last_zero_digit = 0 def to_cardinal(self, value): wrd = "" is_cardinal = self.verify_cardinal(value) if not is_cardinal: return wrd if not int(value) == value: return self.to_cardinal_float(value) if str(value).startswith("-"): pre_word, value = self.negword, float(str(value)[1:]) else: pre_word, value = "", float(value) self.to_splitnum(value) if self.order_of_last_zero_digit >= len(self.integers_to_read[0]): # number like 00 and all 0s and even more, raise error return "%s%s" % (pre_word, wrd) if self.total_triplets_to_read == 1: if self.total_digits_outside_triplets == 2: if self.order_of_last_zero_digit == 1: # number like x0, read cardinal x0 and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit == 0: # number like xy, read cardinal xy and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][1], "" ) return "%s%s" % (pre_word, wrd) if self.total_digits_outside_triplets == 1: if self.order_of_last_zero_digit == 0: # number like x, read cardinal x and return wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][0], "" ) if self.integers_to_read[0][0] == "0": return self.ZERO return "%s%s" % (pre_word, wrd) if self.total_digits_outside_triplets == 0: if self.order_of_last_zero_digit == 2: # number like x00, read cardinal x00 and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit == 1: # number like xy0, read cardinal xy0 and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit == 0: # number like xyz, read cardinal xyz and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][2], "" ) return "%s%s" % (pre_word, wrd) if self.total_triplets_to_read >= 2: if self.total_digits_outside_triplets == 2: if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 1: # number like x0 and all 0s, read cardinal x0 0..0 # and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 2: # number like xy and all 0s, read cardinal xy 0..0 # and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit < len( self.integers_to_read[0]) - 2: # number like xy and others, read cardinal xy n..n # and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] if self.total_digits_outside_triplets == 1: if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 1: # number like x and all 0s, read cardinal x 0..0 # and return if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"): wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit < len( self.integers_to_read[0]) - 1: # number like x and others, read cardinal x n..n # and return if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"): wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] if self.total_digits_outside_triplets == 0: if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 1: # number like x00 and all 0s, read cardinal x00 0..0 # and return wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "") wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 2: # number like xy0 and all 0s, read cardinal xy0 0..0 # and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 3: # number like xyz and all 0s, read cardinal xyz 0..0 # and return wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "") wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][2], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return "%s%s" % (pre_word, wrd) if self.order_of_last_zero_digit < len( self.integers_to_read[0]) - 3: # number like xyz and all others, read cardinal xyz n..n wrd += self.HUNDREDS.get(self.integers_to_read[0][0], "") wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][2] == "1"): wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][2], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] for i in list(range(self.total_triplets_to_read - 1, 0, -1)): reading_triplet_order = self.total_triplets_to_read - i if self.total_digits_outside_triplets == 0: last_read_digit_order = reading_triplet_order * 3 else: last_read_digit_order = (reading_triplet_order - 1) * 3 +\ self.total_digits_outside_triplets if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 3 ] == "000": if not self.integers_to_read[0][ last_read_digit_order ] == "0": wrd += self.HUNDREDS.get( self.integers_to_read[0][last_read_digit_order], "" ) if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - ( last_read_digit_order) - 1: if i == 1: wrd += self.CARDINAL_HUNDRED[0] return "%s%s" % (pre_word, wrd) elif i > 1: wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TRIPLETS[i - 1] return "%s%s" % (pre_word, wrd) else: wrd += self.CARDINAL_HUNDRED[0] if not self.integers_to_read[0][ last_read_digit_order + 1] == "0": if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - ( last_read_digit_order) - 2: if i == 1: wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][ last_read_digit_order + 1], "" ) return "%s%s" % (pre_word, wrd) elif i > 1: wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][ last_read_digit_order + 1], "" ) wrd += self.CARDINAL_TRIPLETS[i - 1] return "%s%s" % (pre_word, wrd) else: wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][ last_read_digit_order + 1], "" ) if not self.integers_to_read[0][ last_read_digit_order + 2] == "0": if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - ( last_read_digit_order) - 3: if i == 1: wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) return "%s%s" % (pre_word, wrd) if i == 2: if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 2 ] == "00": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) elif not self.integers_to_read[0][ last_read_digit_order + 2] == "1": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) wrd += self.CARDINAL_TRIPLETS[i - 1] return "%s%s" % (pre_word, wrd) if i > 2: wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) wrd += self.CARDINAL_TRIPLETS[i - 1] return "%s%s" % (pre_word, wrd) else: if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 2 ] == "00": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) else: if i == 2: if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 2 ] == "00": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) elif not self.integers_to_read[0][ last_read_digit_order + 2 ] == "1": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) wrd += self.CARDINAL_TRIPLETS[i - 1] return "%s%s" % (pre_word, wrd) def to_cardinal_float(self, value): self.to_splitnum(value) wrd = "" wrd += self.pointword if len(self.integers_to_read[1]) >= 1: wrd += self.CARDINAL_TENS.get(self.integers_to_read[1][0], "") if len(self.integers_to_read[1]) == 2: wrd += self.CARDINAL_ONES.get(self.integers_to_read[1][1], "") if self.integers_to_read[0] == "0": wrd = self.ZERO + wrd else: wrd = self.to_cardinal(int(self.integers_to_read[0])) + wrd return wrd def verify_cardinal(self, value): iscardinal = True try: if not float(value) == value: iscardinal = False except (ValueError, TypeError): raise TypeError(self.errmsg_nonnum) if abs(value) >= self.MAXVAL: raise OverflowError(self.errmsg_toobig.format(value, self.MAXVAL)) return iscardinal def verify_ordinal(self, value): isordinal = True try: if not int(value) == value: isordinal = False if not abs(value) == value: raise TypeError(self.errmsg_negord.format(value)) except (ValueError, TypeError): raise TypeError(self.errmsg_nonnum) if abs(value) >= self.MAXVAL: raise OverflowError(self.errmsg_toobig.format(value, self.MAXVAL)) return isordinal def to_ordinal(self, value): wrd = "" isordinal = self.verify_ordinal(value) if isordinal: self.to_splitnum(value) if self.order_of_last_zero_digit >= len(self.integers_to_read[0]): # number like 00 and all 0s and even more, raise error return wrd if self.total_triplets_to_read == 1: if self.total_digits_outside_triplets == 2: if self.order_of_last_zero_digit == 1: # number like x0, read ordinal x0 and return wrd += self.ORDINAL_TENS.get( self.integers_to_read[0][0], "" ) return wrd if self.order_of_last_zero_digit == 0: # number like xy, read ordinal xy and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.ORDINAL_ONES.get( self.integers_to_read[0][1], "" ) return wrd if self.total_digits_outside_triplets == 1: if self.order_of_last_zero_digit == 0: # number like x, read ordinal x and return wrd += self.ORDINAL_ONES.get( self.integers_to_read[0][0], "" ) if self.integers_to_read[0][0] == "0": return u"sıfırıncı" return wrd if self.total_digits_outside_triplets == 0: if self.order_of_last_zero_digit == 2: # number like x00, read ordinal x00 and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.ORDINAL_HUNDRED[0] return wrd if self.order_of_last_zero_digit == 1: # number like xy0, read ordinal xy0 and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.ORDINAL_TENS.get( self.integers_to_read[0][1], "" ) return wrd if self.order_of_last_zero_digit == 0: # number like xyz, read ordinal xyz and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) if not self.integers_to_read[0][2] == "0": wrd += self.ORDINAL_ONES.get( self.integers_to_read[0][2], "" ) return wrd if self.total_triplets_to_read >= 2: if self.total_digits_outside_triplets == 2: if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 1: # number like x0 and all 0s, read ordinal x0 0..0 # and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.ORDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return wrd if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 2: # number like xy and all 0s, read ordinal xy 0..0 # and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][1], "" ) wrd += self.ORDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return wrd if self.order_of_last_zero_digit < len( self.integers_to_read[0]) - 2: # number like xy and others, read cardinal xy n..n # and return wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] if self.total_digits_outside_triplets == 1: if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 1: # number like x and all 0s, read ordinal x 0..0 # and return if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"): wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][0], "" ) wrd += self.ORDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return wrd if self.order_of_last_zero_digit < len( self.integers_to_read[0]) - 1: # number like x and others, read cardinal x n..n # and return if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][0] == "1"): wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] if self.total_digits_outside_triplets == 0: if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 1: # number like x00 and all 0s, read ordinal x00 0..0 # and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.ORDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return wrd if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 2: # number like xy0 and all 0s, read ordinal xy0 0..0 # and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) wrd += self.ORDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return wrd if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - 3: # number like xyz and all 0s, read ordinal xyz 0..0 # and return wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][2], "" ) wrd += self.ORDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] return wrd if self.order_of_last_zero_digit < len( self.integers_to_read[0]) - 3: # number like xyz and all others, read cardinal # xyz n..n wrd += self.HUNDREDS.get( self.integers_to_read[0][0], "" ) wrd += self.CARDINAL_HUNDRED[0] wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][1], "" ) if not (self.total_triplets_to_read == 2 and self.integers_to_read[0][2] == "1"): wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][2], "" ) wrd += self.CARDINAL_TRIPLETS[ self.total_triplets_to_read - 1 ] for i in list(range(self.total_triplets_to_read - 1, 0, -1)): reading_triplet_order = self.total_triplets_to_read - i if self.total_digits_outside_triplets == 0: last_read_digit_order = reading_triplet_order * 3 else: last_read_digit_order = \ (reading_triplet_order - 1) * 3 + \ self.total_digits_outside_triplets if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 3 ] == "000": if not self.integers_to_read[0][ last_read_digit_order ] == "0": if not self.integers_to_read[0][ last_read_digit_order ] == "1": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order ], "" ) if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - ( last_read_digit_order) - 1: if i == 1: wrd += self.ORDINAL_HUNDRED[0] return wrd elif i > 1: wrd += self.CARDINAL_HUNDRED[0] wrd += self.ORDINAL_TRIPLETS[i - 1] return wrd else: wrd += self.CARDINAL_HUNDRED[0] if not self.integers_to_read[0][ last_read_digit_order + 1 ] == "0": if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - ( last_read_digit_order) - 2: if i == 1: wrd += self.ORDINAL_TENS.get( self.integers_to_read[0][ last_read_digit_order + 1], "" ) return wrd elif i > 1: wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][ last_read_digit_order + 1], "" ) wrd += self.ORDINAL_TRIPLETS[i - 1] return wrd else: wrd += self.CARDINAL_TENS.get( self.integers_to_read[0][ last_read_digit_order + 1], "" ) if not self.integers_to_read[0][ last_read_digit_order + 2 ] == "0": if self.order_of_last_zero_digit == len( self.integers_to_read[0]) - ( last_read_digit_order) - 3: if i == 1: wrd += self.ORDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) return wrd if i == 2: if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 2] == "00": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) elif not self.integers_to_read[0][ last_read_digit_order + 2 ] == "1": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) wrd += self.ORDINAL_TRIPLETS[i - 1] return wrd if i > 2: wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) wrd += self.ORDINAL_TRIPLETS[i - 1] return wrd else: if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 2] == "00": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) else: if not self.integers_to_read[0][ last_read_digit_order: last_read_digit_order + 2] == "00": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) elif not self.integers_to_read[0][ last_read_digit_order + 2] == "1": wrd += self.CARDINAL_ONES.get( self.integers_to_read[0][ last_read_digit_order + 2], "" ) wrd += self.CARDINAL_TRIPLETS[i - 1] return wrd def to_ordinal_num(self, value): self.verify_ordinal(value) return "%s%s" % (value, self.to_ordinal(value)[-4:]) def to_splitnum(self, val): float_digits = str(int(val * 10 ** self.precision)) if not int(val) == 0: self.integers_to_read = [ str(int(val)), float_digits[len(float_digits) - self.precision:] ] else: self.integers_to_read = [ "0", "0" * (self.precision - len(float_digits)) + float_digits[len(float_digits) - self.precision:] ] if len(self.integers_to_read[0]) % 3 > 0: self.total_triplets_to_read = (len(self.integers_to_read[0]) // 3)\ + 1 elif len(self.integers_to_read[0]) % 3 == 0: self.total_triplets_to_read = len(self.integers_to_read[0]) // 3 self.total_digits_outside_triplets = len(self.integers_to_read[0]) % 3 okunacak = list(self.integers_to_read[0][::-1]) self.order_of_last_zero_digit = 0 found = 0 for i in range(len(okunacak) - 1): if int(okunacak[i]) == 0 and found == 0: self.order_of_last_zero_digit = i + 1 else: found = 1 def to_currency(self, value): if int(value) == 0: return u"bedelsiz" valueparts = self.to_cardinal(value).split(self.pointword) if len(valueparts) == 1: return valueparts[0] + self.CURRENCY_UNIT if len(valueparts) == 2: return self.CURRENCY_UNIT.join(valueparts) + \ self.CURRENCY_SUBUNIT num2words-0.5.14/num2words/lang_UK.py000066400000000000000000001177041473005321200174020ustar00rootroot00000000000000# -*- 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 .base import Num2Word_Base from .utils import get_digits, splitbyx ZERO = ('нуль',) ONES_FEMININE = { 1: ('одна', "однієї", "одній", "одну", "однією", "одній"), 2: ('дві', "двох", "двом", "дві", "двома", "двох"), 3: ('три', "трьох", "трьом", "три", "трьома", "трьох"), 4: ('чотири', "чотирьох", "чотирьом", "чотири", "чотирма", "чотирьох"), 5: ('п\'ять', "п'яти", "п'яти", "п'ять", "п'ятьма", "п'яти"), 6: ('шість', "шести", "шести", "шість", "шістьма", "шести"), 7: ('сім', "семи", "семи", "сім", "сьома", "семи"), 8: ('вісім', "восьми", "восьми", "вісім", "вісьма", "восьми"), 9: ("дев'ять", "дев'яти", "дев'яти", "дев'ять", "дев'ятьма", "дев'яти"), } ONES = { 1: ('один', 'одного', "одному", "один", "одним", "одному"), 2: ('два', 'двох', "двом", "два", "двома", "двох"), 3: ('три', 'трьох', "трьом", "три", "трьома", "трьох"), 4: ('чотири', 'чотирьох', "чотирьом", "чотири", "чотирма", "чотирьох"), 5: ('п\'ять', "п'яти", "п'яти", "п'ять", "п'ятьма", "п'яти"), 6: ('шість', 'шести', "шести", "шість", "шістьма", "шести"), 7: ('сім', 'семи', "семи", "сім", "сьома", "семи"), 8: ('вісім', 'восьми', "восьми", "вісім", "вісьма", "восьми"), 9: ("дев'ять", "дев'яти", "дев'яти", "дев'ять", "дев'ятьма", "дев'яти"), } ONES_ORDINALS = { 1: ("перший", "одно"), 2: ("другий", "двох"), 3: ("третій", "трьох"), 4: ("четвертий", "чотирьох"), 5: ("п'ятий", "п'яти"), 6: ("шостий", "шести"), 7: ("сьомий", "семи"), 8: ("восьмий", "восьми"), 9: ("дев'ятий", "дев'яти"), 10: ("десятий", "десяти"), 11: ("одинадцятий", "одинадцяти"), 12: ("дванадцятий", "дванадцяти"), 13: ("тринадцятий", "тринадцяти"), 14: ("чотирнадцятий", "чотирнадцяти"), 15: ("п'ятнадцятий", "п'ятнадцяти"), 16: ("шістнадцятий", "шістнадцяти"), 17: ("сімнадцятий", "сімнадцяти"), 18: ("вісімнадцятий", "вісімнадцяти"), 19: ("дев'ятнадцятий", "дев'ятнадцяти"), } TENS = { 0: ('десять', 'десяти', "десяти", "десять", "десятьма", "десяти"), 1: ('одинадцять', 'одинадцяти', "одинадцяти", "одинадцять", "одинадцятьма", "одинадцяти"), 2: ('дванадцять', 'дванадцяти', "дванадцяти", "дванадцять", "дванадцятьма", "дванадцяти"), 3: ('тринадцять', 'тринадцяти', "тринадцяти", "тринадцять", "тринадцятьма", "тринадцяти"), 4: ('чотирнадцять', 'чотирнадцяти', "чотирнадцяти", "чотирнадцять", "чотирнадцятьма", "чотирнадцяти"), 5: ("п'ятнадцять", "п'ятнадцяти", "п'ятнадцяти", "п'ятнадцять", "п'ятнадцятьма", "п'ятнадцяти"), 6: ('шістнадцять', 'шістнадцяти', "шістнадцяти", "шістнадцять", "шістнадцятьма", "шістнадцяти"), 7: ('сімнадцять', 'сімнадцяти', "сімнадцяти", "сімнадцять", "сімнадцятьма", "сімнадцяти"), 8: ('вісімнадцять', 'вісімнадцяти', "вісімнадцяти", "вісімнадцять", "вісімнадцятьма", "вісімнадцяти"), 9: ("дев'ятнадцять", "дев'ятнадцяти", "дев'ятнадцяти", "дев'ятнадцять", "дев'ятнадцятьма", "дев'ятнадцяти"), } TWENTIES = { 2: ('двадцять', "двадцяти", "двадцяти", "двадцять", "двадцятьма", "двадцяти"), 3: ('тридцять', "тридцяти", "тридцяти", "тридцять", "тридцятьма", "тридцяти"), 4: ('сорок', "сорока", "сорока", "сорок", "сорока", "сорока"), 5: ('п\'ятдесят', "п'ятдесяти", "п'ятдесяти", "п'ятдесят", "п'ятдесятьма", "п'ятдесяти"), 6: ('шістдесят', "шістдесяти", "шістдесяти", "шістдесят", "шістдесятьма", "шістдесяти"), 7: ('сімдесят', "сімдесяти", "сімдесяти", "сімдесят", "сімдесятьма", "сімдесяти"), 8: ('вісімдесят', "вісімдесяти", "вісімдесяти", "вісімдесят", "вісімдесятьма", "вісімдесяти"), 9: ('дев\'яносто', "дев'яноста", "дев'яноста", "дев'яносто", "дев'яностами", "дев'яноста"), } TWENTIES_ORDINALS = { 2: ("двадцятий", "двадцяти"), 3: ("тридцятий", "тридцяти"), 4: ("сороковий", "сорока"), 5: ("п'ятдесятий", "п'ятдесяти"), 6: ("шістдесятий", "шістдесяти"), 7: ("сімдесятий", "сімдесяти"), 8: ("вісімдесятий", "вісімдесяти"), 9: ("дев'яностий", "дев'яности"), } HUNDREDS = { 1: ('сто', "ста", "ста", "сто", "стами", "стах"), 2: ('двісті', "двохста", "двомстам", "двісті", "двомастами", "двохстах"), 3: ('триста', "трьохста", "трьомстам", "триста", "трьомастами", "трьохстах"), 4: ('чотириста', "чотирьохста", "чотирьомстам", "чотириста", "чотирмастами", "чотирьохстах"), 5: ('п\'ятсот', "п'ятиста", "п'ятистам", "п'ятсот", "п'ятьмастами", "п'ятистах"), 6: ('шістсот', "шестиста", "шестистам", "шістсот", "шістьмастами", "шестистах"), 7: ('сімсот', "семиста", "семистам", "сімсот", "сьомастами", "семистах"), 8: ('вісімсот', "восьмиста", "восьмистам", "вісімсот", "восьмастами", "восьмистах"), 9: ("дев'ятсот", "дев'ятиста", "дев'ятистам", "дев'ятсот", "дев'ятьмастами", "дев'ятистах"), } HUNDREDS_ORDINALS = { 1: ("сотий", "сто"), 2: ("двохсотий", "двохсот"), 3: ("трьохсотий", "трьохсот"), 4: ("чотирьохсотий", "чотирьохсот"), 5: ("п'ятисотий", "п'ятсот"), 6: ("шестисотий", "шістсот"), 7: ("семисотий", "сімсот"), 8: ("восьмисотий", "вісімсот"), 9: ("дев'ятисотий", "дев'ятсот"), } THOUSANDS = { # 10^3 1: (('тисяча', 'тисячі', 'тисяч'), ('тисячи', 'тисяч', 'тисяч'), ('тисячі', 'тисячам', 'тисячам'), ('тисячу', 'тисячі', 'тисяч'), ('тисячею', 'тисячами', 'тисячами'), ('тисячі', 'тисячах', 'тисячах'),), # 10^6 2: (('мільйон', 'мільйони', 'мільйонів'), ('мільйона', 'мільйонів', 'мільйонів'), ('мільйону', 'мільйонам', 'мільйонам'), ('мільйон', 'мільйони', 'мільйонів'), ('мільйоном', 'мільйонами', 'мільйонів'), ('мільйоні', 'мільйонах', 'мільйонах'),), # 10^9 3: (('мільярд', 'мільярди', 'мільярдів'), ('мільярда', 'мільярдів', 'мільярдів'), ('мільярду', 'мільярдам', 'мільярдам'), ('мільярд', 'мільярди', 'мільярдів'), ('мільярдом', 'мільярдами', 'мільярдів'), ('мільярді', 'мільярдах', 'мільярдах'),), # 10^12 4: (('трильйон', 'трильйони', 'трильйонів'), ('трильйона', 'трильйонів', 'трильйонів'), ('трильйону', 'трильйонам', 'трильйонам'), ('трильйон', 'трильйони', 'трильйонів'), ('трильйоном', 'трильйонами', 'трильйонів'), ('трильйоні', 'трильйонах', 'трильйонах'),), # 10^15 5: (('квадрильйон', 'квадрильйони', 'квадрильйонів'), ('квадрильйона', 'квадрильйонів', 'квадрильйонів'), ('квадрильйону', 'квадрильйонам', 'квадрильйонам'), ('квадрильйон', 'квадрильйони', 'квадрильйонів'), ('квадрильйоном', 'квадрильйонами', 'квадрильйонів'), ('квадрильйоні', 'квадрильйонах', 'квадрильйонах'),), # 10^18 6: (('квінтильйон', 'квінтильйони', 'квінтильйонів'), ('квінтильйона', 'квінтильйонів', 'квінтильйонів'), ('квінтильйону', 'квінтильйонам', 'квінтильйонам'), ('квінтильйон', 'квінтильйони', 'квінтильйонів'), ('квінтильйоном', 'квінтильйонами', 'квінтильйонів'), ('квінтильйоні', 'квінтильйонах', 'квінтильйонах'),), # 10^21 7: (('секстильйон', 'секстильйони', 'секстильйонів'), ('секстильйона', 'секстильйонів', 'секстильйонів'), ('секстильйону', 'секстильйонам', 'секстильйонам'), ('секстильйон', 'секстильйони', 'секстильйонів'), ('секстильйоном', 'секстильйонами', 'секстильйонів'), ('секстильйоні', 'секстильйонах', 'секстильйонах'),), # 10^24 8: (('септильйон', 'септильйони', 'септильйонів'), ('септильйона', 'септильйонів', 'септильйонів'), ('септильйону', 'септильйонам', 'септильйонам'), ('септильйон', 'септильйони', 'септильйонів'), ('септильйоном', 'септильйонами', 'септильйонів'), ('септильйоні', 'септильйонах', 'септильйонах'),), # 10^27 9: (('октильйон', 'октильйони', 'октильйонів'), ('октильйона', 'октильйонів', 'октильйонів'), ('октильйону', 'октильйонам', 'октильйонам'), ('октильйон', 'октильйони', 'октильйонів'), ('октильйоном', 'октильйонами', 'октильйонів'), ('октильйоні', 'октильйонах', 'октильйонах'),), # 10^30 10: (('нонільйон', 'нонільйони', 'нонільйонів'), ('нонільйона', 'нонільйонів', 'нонільйонів'), ('нонільйону', 'нонільйонам', 'нонільйонам'), ('нонільйон', 'нонільйони', 'нонільйонів'), ('нонільйоном', 'нонільйонами', 'нонільйонів'), ('нонільйоні', 'нонільйонах', 'нонільйонах'),), } prefixes_ordinal = { 1: "тисячний", 2: "мільйонний", 3: "мільярдний", 4: "трильйонний", 5: "квадрильйонний", 6: "квінтильйонний", 7: "секстильйонний", 8: "септильйонний", 9: "октильйонний", 10: "нонільйонний", } FEMININE_MONEY = ('AOA', 'BAM', 'BDT', 'BWP', 'CZK', 'DKK', 'ERN', 'HNL', 'HRK', 'IDR', 'INR', 'ISK', 'JPY', 'KPW', 'KRW', 'LKR', 'MOP', 'MRU', 'MUR', 'MVR', 'MWK', 'NGN', 'NIO', 'NOK', 'NPR', 'PKR', 'SCR', 'SEK', 'STN', 'TRY', 'WST', 'UAH', 'ZMW') FEMININE_CENTS = ('ALL', 'BDT', 'BGN', 'BYN', 'GHS', 'HRK', 'ILS', 'INR', 'NPR', 'OMR', 'OMR', 'PKR', 'RSD', 'RUB', 'UAH') GENERIC_DOLLARS = ('долар', 'долари', 'доларів') GENERIC_CENTS = ('цент', 'центи', 'центів') class Num2Word_UK(Num2Word_Base): CURRENCY_FORMS = { 'AED': ( ('дирхам', 'дирхами', 'дирхамів'), ('філс', 'філси', 'філсів') ), 'AFN': ( ('афгані', 'афгані', 'афгані'), ('пул', 'пули', 'пулів') ), 'ALL': ( ('лек', 'леки', 'леків'), ('кіндарка', 'кіндарки', 'кіндарок') ), 'AMD': ( ('драм', 'драми', 'драмів'), ('лум', 'лум', 'лум') ), 'ANG': ( ('гульден', 'гульдени', 'гульденів'), GENERIC_CENTS ), 'AOA': ( ('кванза', 'кванзи', 'кванз'), ('сентимо', 'сентимо', 'сентимо') ), 'ARS': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'AUD': (GENERIC_DOLLARS, GENERIC_CENTS), 'AWG': ( ('флорин', 'флорини', 'флоринів'), GENERIC_CENTS ), 'AZN': ( ('манат', 'манати', 'манатів'), ('гяпік', 'гяпіки', 'гяпіків') ), 'BAM': ( ('марка', 'марки', 'марок'), ('фенінг', 'фенінги', 'фенінгів') ), 'BBD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BDT': ( ('така', 'таки', 'так'), ('пойша', 'пойші', 'пойш') ), 'BGN': ( ('лев', 'леви', 'левів'), ('стотинка', 'стотинки', 'стотинок') ), 'BHD': ( ('динар', 'динари', 'динарів'), ('філс', 'філси', 'філсів') ), 'BIF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'BMD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BND': (GENERIC_DOLLARS, GENERIC_CENTS), 'BOB': ( ('болівіано', 'болівіано', 'болівіано'), ('сентаво', 'сентаво', 'сентаво') ), 'BRL': ( ('реал', 'реали', 'реалів'), ('сентаво', 'сентаво', 'сентаво') ), 'BSD': (GENERIC_DOLLARS, GENERIC_CENTS), 'BTN': ( ('нгултрум', 'нгултруми', 'нгултрумів'), ('четрум', 'четруми', 'четрумів') ), 'BWP': ( ('пула', 'пули', 'пул'), ('тхебе', 'тхебе', 'тхебе') ), 'BYN': ( ('рубель', 'рублі', 'рублів'), ('копійка', 'копійки', 'копійок') ), 'BZD': (GENERIC_DOLLARS, GENERIC_CENTS), 'CAD': (GENERIC_DOLLARS, GENERIC_CENTS), 'CDF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'CHF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'CLP': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'CNY': ( ('юань', 'юані', 'юанів'), ('финь', 'фині', 'финів') ), 'COP': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'CRC': ( ('колон', 'колони', 'колонів'), ('сентімо', 'сентімо', 'сентімо') ), 'CUC': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'CUP': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'CVE': ( ('ескудо', 'ескудо', 'ескудо'), ('сентаво', 'сентаво', 'сентаво') ), 'CZK': ( ('крона', 'крони', 'крон'), ('гелер', 'гелери', 'гелерів') ), 'DJF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'DKK': ( ('крона', 'крони', 'крон'), ('ере', 'ере', 'ере') ), 'DOP': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'DZD': ( ('динар', 'динари', 'динарів'), ('сантим', 'сантими', 'сантимів') ), 'EGP': ( ('фунт', 'фунти', 'фунтів'), ('піастр', 'піастри', 'піастрів') ), 'ERN': ( ('накфа', 'накфи', 'накф'), GENERIC_CENTS ), 'ETB': ( ('бир', 'бири', 'бирів'), GENERIC_CENTS ), 'EUR': ( ('євро', 'євро', 'євро'), GENERIC_CENTS ), 'FJD': (GENERIC_DOLLARS, GENERIC_CENTS), 'FKP': ( ('фунт', 'фунти', 'фунтів'), ('пенс', 'пенси', 'пенсів') ), 'GBP': ( ('фунт', 'фунти', 'фунтів'), ('пенс', 'пенси', 'пенсів') ), 'GEL': ( ('ларі', 'ларі', 'ларі'), ('тетрі', 'тетрі', 'тетрі') ), 'GHS': ( ('седі', 'седі', 'седі'), ('песева', 'песеви', 'песев') ), 'GIP': ( ('фунт', 'фунти', 'фунтів'), ('пенс', 'пенси', 'пенсів') ), 'GMD': ( ('даласі', 'даласі', 'даласі'), ('бутут', 'бутути', 'бутутів') ), 'GNF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'GTQ': ( ('кетсаль', 'кетсалі', 'кетсалів'), ('сентаво', 'сентаво', 'сентаво') ), 'GYD': (GENERIC_DOLLARS, GENERIC_CENTS), 'HKD': (GENERIC_DOLLARS, GENERIC_CENTS), 'HNL': ( ('лемпіра', 'лемпіри', 'лемпір'), ('сентаво', 'сентаво', 'сентаво') ), 'HRK': ( ('куна', 'куни', 'кун'), ('ліпа', 'ліпи', 'ліп') ), 'HTG': ( ('гурд', 'гурди', 'гурдів'), ('сантим', 'сантими', 'сантимів') ), 'HUF': ( ('форинт', 'форинти', 'форинтів'), ('філлер', 'філлери', 'філлерів') ), 'IDR': ( ('рупія', 'рупії', 'рупій'), GENERIC_CENTS ), 'ILS': ( ('шекель', 'шекелі', 'шекелів'), ('агора', 'агори', 'агор') ), 'INR': ( ('рупія', 'рупії', 'рупій'), ('пайса', 'пайси', 'пайс') ), 'IQD': ( ('динар', 'динари', 'динарів'), ('філс', 'філси', 'філсів') ), 'IRR': ( ('ріал', 'ріали', 'ріалів'), ('динар', 'динари', 'динарів') ), 'ISK': ( ('крона', 'крони', 'крон'), ('ейре', 'ейре', 'ейре') ), 'JMD': (GENERIC_DOLLARS, GENERIC_CENTS), 'JOD': ( ('динар', 'динари', 'динарів'), ('філс', 'філси', 'філсів') ), 'JPY': ( ('єна', 'єни', 'єн'), ('сен', 'сен', 'сен') ), 'KES': ( ('шилінг', 'шилінги', 'шилінгів'), GENERIC_CENTS ), 'KGS': ( ('сом', 'соми', 'сомів'), ('тиїн', 'тиїни', 'тиїнів') ), 'KHR': ( ('рієль', 'рієлі', 'рієлів'), ('су', 'су', 'су') ), 'KMF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'KPW': ( ('вона', 'вони', 'вон'), ('чон', 'чони', 'чонів') ), 'KRW': ( ('вона', 'вони', 'вон'), ('джеон', 'джеони', 'джеонів') ), 'KWD': ( ('динар', 'динари', 'динарів'), ('філс', 'філси', 'філсів') ), 'KYD': (GENERIC_DOLLARS, GENERIC_CENTS), 'KZT': ( ('теньге', 'теньге', 'теньге'), ('тиїн', 'тиїни', 'тиїнів')), 'LAK': ( ('кіп', 'кіпи', 'кіпів'), ('ат', 'ати', 'атів') ), 'LBP': ( ('фунт', 'фунти', 'фунтів'), ('піастр', 'піастри', 'піастрів') ), 'LKR': ( ('рупія', 'рупії', 'рупій'), GENERIC_CENTS ), 'LRD': (GENERIC_DOLLARS, GENERIC_CENTS), 'LSL': ( ('лоті', 'малоті', 'малоті'), ('сенте', 'лісенте', 'лісенте') ), 'LYD': ( ('динар', 'динари', 'динарів'), ('дирхам', 'дирхами', 'дирхамів') ), 'MAD': ( ('дирхам', 'дирхами', 'дирхамів'), ('сантим', 'сантими', 'сантимів') ), 'MDL': ( ('лей', 'леї', 'леї'), ('бан', 'бані', 'бані') ), 'MGA': ( ('аріарі', 'аріарі', 'аріарі'), ('іраймбіланья', 'іраймбіланья', 'іраймбіланья') ), 'MKD': ( ('денар', 'денари', 'денарів'), ('дені', 'дені', 'дені') ), 'MMK': ( ('к\'ят', 'к\'ят', 'к\'ят'), ('п\'я', 'п\'я', 'п\'я') ), 'MNT': ( ('тугрик', 'тугрики', 'тугриків'), ('мунгу', 'мунгу', 'мунгу') ), 'MOP': ( ('патака', 'патакі', 'патак'), ('аво', 'аво', 'аво') ), 'MRU': ( ('угія', 'угії', 'угій'), ('хумс', 'хумс', 'хумс') ), 'MUR': ( ('рупія', 'рупії', 'рупій'), GENERIC_CENTS ), 'MVR': ( ('руфія', 'руфії', 'руфій'), ('ларі', 'ларі', 'ларі') ), 'MWK': ( ('квача', 'квачі', 'квач'), ('тамбала', 'тамбала', 'тамбала') ), 'MXN': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'MYR': ( ('рингіт', 'рингіти', 'рингітів'), GENERIC_CENTS ), 'MZN': ( ('метікал', 'метікали', 'метікалів'), ('сентаво', 'сентаво', 'сентаво') ), 'NAD': (GENERIC_DOLLARS, GENERIC_CENTS), 'NGN': ( ('найра', 'найри', 'найр'), ('кобо', 'кобо', 'кобо') ), 'NIO': ( ('кордоба', 'кордоби', 'кордоб'), ('сентаво', 'сентаво', 'сентаво') ), 'NOK': ( ('крона', 'крони', 'крон'), ('ере', 'ере', 'ере') ), 'NPR': ( ('рупія', 'рупії', 'рупій'), ('пайса', 'пайси', 'пайс') ), 'NZD': (GENERIC_DOLLARS, GENERIC_CENTS), 'OMR': ( ('ріал', 'ріали', 'ріалів'), ('байза', 'байзи', 'байз') ), 'PAB': ( ('бальбоа', 'бальбоа', 'бальбоа'), ('сентесімо', 'сентесімо', 'сентесімо') ), 'PEN': ( ('соль', 'соль', 'соль'), ('сентімо', 'сентімо', 'сентімо') ), 'PGK': ( ('кіна', 'кіна', 'кіна'), ('тойя', 'тойя', 'тойя') ), 'PHP': ( ('песо', 'песо', 'песо'), ('сентаво', 'сентаво', 'сентаво') ), 'PKR': ( ('рупія', 'рупії', 'рупій'), ('пайса', 'пайси', 'пайс') ), 'PLN': ( ('злотий', 'злоті', 'злотих'), ('грош', 'гроші', 'грошів') ), 'PYG': ( ('гуарані', 'гуарані', 'гуарані'), ('сентімо', 'сентімо', 'сентімо') ), 'QAR': ( ('ріал', 'ріали', 'ріалів'), ('дирхам', 'дирхами', 'дирхамів') ), 'RON': ( ('лей', 'леї', 'леї'), ('бан', 'бані', 'бані') ), 'RSD': ( ('динар', 'динари', 'динарів'), ('пара', 'пари', 'пар') ), 'RUB': ( ('рубль', 'рублі', 'рублів'), ('копійка', 'копійки', 'копійок') ), 'RWF': ( ('франк', 'франки', 'франків'), ('сантим', 'сантими', 'сантимів') ), 'SAR': ( ('ріал', 'ріали', 'ріалів'), ('халал', 'халали', 'халалів') ), 'SBD': (GENERIC_DOLLARS, GENERIC_CENTS), 'SCR': ( ('рупія', 'рупії', 'рупій'), GENERIC_CENTS ), 'SDG': ( ('фунт', 'фунти', 'фунтів'), ('піастр', 'піастри', 'піастрів') ), 'SEK': ( ('крона', 'крони', 'крон'), ('ере', 'ере', 'ере') ), 'SGD': (GENERIC_DOLLARS, GENERIC_CENTS), 'SHP': ( ('фунт', 'фунти', 'фунтів'), ('пенс', 'пенси', 'пенсів') ), 'SLL': ( ('леоне', 'леоне', 'леоне'), GENERIC_CENTS ), 'SOS': ( ('шилінг', 'шилінги', 'шилінгів'), GENERIC_CENTS ), 'SRD': (GENERIC_DOLLARS, GENERIC_CENTS), 'SSP': ( ('фунт', 'фунти', 'фунтів'), ('піастр', 'піастри', 'піастрів') ), 'STN': ( ('добра', 'добри', 'добр'), ('сентімо', 'сентімо', 'сентімо') ), 'SYP': ( ('фунт', 'фунти', 'фунтів'), ('піастр', 'піастри', 'піастрів') ), 'SZL': ( ('ліланґені', 'ліланґені', 'ліланґені'), GENERIC_CENTS ), 'THB': ( ('бат', 'бати', 'батів'), ('сатанг', 'сатанги', 'сатангів') ), 'TJS': ( ('сомоні', 'сомоні', 'сомоні'), ('дірам', 'дірами', 'дірамів') ), 'TMT': ( ('манат', 'манати', 'манатів'), ('тенге', 'тенге', 'тенге') ), 'TND': ( ('динар', 'динари', 'динарів'), ('міллім', 'мілліми', 'міллімів') ), 'TOP': ( ('паанга', 'паанга', 'паанга'), ('сеніті', 'сеніті', 'сеніті') ), 'TRY': ( ('ліра', 'ліри', 'лір'), ('куруш', 'куруші', 'курушів') ), 'TTD': (GENERIC_DOLLARS, GENERIC_CENTS), 'TWD': ( ('новий долар', 'нові долари', 'нових доларів'), GENERIC_CENTS ), 'TZS': ( ('шилінг', 'шилінги', 'шилінгів'), GENERIC_CENTS ), 'UAH': ( ('гривня', 'гривні', 'гривень'), ('копійка', 'копійки', 'копійок') ), 'UGX': ( ('шилінг', 'шилінги', 'шилінгів'), GENERIC_CENTS ), 'USD': (GENERIC_DOLLARS, GENERIC_CENTS), 'UYU': ( ('песо', 'песо', 'песо'), ('сентесімо', 'сентесімо', 'сентесімо') ), 'UZS': ( ('сум', 'суми', 'сумів'), ('тиїн', 'тиїни', 'тиїнів') ), 'VND': ( ('донг', 'донги', 'донгів'), ('су', 'су', 'су') ), 'WST': ( ('тала', 'тали', 'тал'), ('сене', 'сене', 'сене') ), 'XCD': (GENERIC_DOLLARS, GENERIC_CENTS), 'YER': ( ('ріал', 'ріали', 'ріалів'), ('філс', 'філси', 'філсів') ), 'ZAR': ( ('ранд', 'ранди', 'рандів'), GENERIC_CENTS ), 'ZMW': ( ('квача', 'квачі', 'квач'), ('нгве', 'нгве', 'нгве') ), } def setup(self): self.negword = "мінус" self.pointword = "кома" def to_cardinal(self, number, **kwargs): if 'case' in kwargs: case = kwargs['case'] morphological_case = [ "nominative", "genitive", "dative", "accusative", "instrumental", "locative"].index(case) else: morphological_case = 0 if 'gender' in kwargs: gender = kwargs['gender'] == 'feminine' else: gender = False n = str(number).replace(',', '.') if '.' in n: left, right = n.split('.') leading_zero_count = len(right) - len(right.lstrip('0')) right_side = self._int2word(int(right), gender, morphological_case) decimal_part = ((ZERO[0] + ' ') * leading_zero_count + right_side) return u'%s %s %s' % ( self._int2word(int(left), gender, morphological_case), self.pointword, decimal_part ) else: return self._int2word(int(n), gender, morphological_case) def pluralize(self, n, forms): if n % 100 < 10 or n % 100 > 20: if n % 10 == 1: form = 0 elif 5 > n % 10 > 1: form = 1 else: form = 2 else: form = 2 return forms[form] def _int2word(self, n, feminine=False, morphological_case=0): if n < 0: n_value = self._int2word(abs(n), feminine, morphological_case) return ' '.join([self.negword, n_value]) if n == 0: return ZERO[0] words = [] chunks = list(splitbyx(str(n), 3)) i = len(chunks) for x in chunks: i -= 1 if x == 0: continue n1, n2, n3 = get_digits(x) if n3 > 0: words.append(HUNDREDS[n3][morphological_case]) if n2 > 1: words.append(TWENTIES[n2][morphological_case]) if n2 == 1: words.append(TENS[n1][morphological_case]) # elif n1 > 0 and not (i > 0 and x == 1): elif n1 > 0: ones = ONES_FEMININE if i == 1 or feminine and i == 0 else ONES words.append(ones[n1][morphological_case]) if i > 0: thousands_val = THOUSANDS[i][morphological_case] words.append(self.pluralize(x, thousands_val)) return ' '.join(words) def _money_verbose(self, number, currency): return self._int2word(number, currency in FEMININE_MONEY) def _cents_verbose(self, number, currency): return self._int2word(number, currency in FEMININE_CENTS) @staticmethod def last_fragment_to_ordinal(last, words, level): n1, n2, n3 = get_digits(last) last_two = n2*10+n1 if last_two == 0: words.append(HUNDREDS_ORDINALS[n3][level]) elif level == 1 and last == 1: return elif last_two < 20: if level == 0: if n3 > 0: words.append(HUNDREDS[n3][0]) words.append(ONES_ORDINALS[last_two][0]) else: last_fragment_string = '' if n3 > 0: last_fragment_string += HUNDREDS_ORDINALS[n3][1] last_fragment_string += ONES_ORDINALS[last_two][1] words.append(last_fragment_string) elif last_two % 10 == 0: if level == 0: if n3 > 0: words.append(HUNDREDS[n3][0]) words.append(TWENTIES_ORDINALS[n2][0]) else: last_fragment_string = '' if n3 > 0: last_fragment_string += HUNDREDS_ORDINALS[n3][1] last_fragment_string += TWENTIES_ORDINALS[n2][1] words.append(last_fragment_string) else: if level == 0: if n3 > 0: words.append(HUNDREDS[n3][0]) words.append(TWENTIES[n2][0]) words.append(ONES_ORDINALS[n1][0]) else: last_fragment_string = '' if n3 > 0: last_fragment_string += HUNDREDS_ORDINALS[n3][1] last_fragment_string += TWENTIES_ORDINALS[n2][1] last_fragment_string += ONES_ORDINALS[n1][1] words.append(last_fragment_string) def to_ordinal(self, number): self.verify_ordinal(number) words = [] fragments = list(splitbyx(str(number), 3)) level = 0 last = fragments[-1] while last == 0: level = level + 1 fragments.pop() last = fragments[-1] if len(fragments) > 1: pre_part = self._int2word(number - (last * 1000 ** level)) words.append(pre_part) Num2Word_UK.last_fragment_to_ordinal( last, words, 0 if level == 0 else 1 ) output = " ".join(words) if last == 1 and level > 0 and output != "": output = output + " " if level > 0: output = output + prefixes_ordinal[level] return output num2words-0.5.14/num2words/lang_VI.py000066400000000000000000000100671473005321200173730ustar00rootroot00000000000000# -*- 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 to_19 = (u'không', u'một', u'hai', u'ba', u'bốn', u'năm', u'sáu', u'bảy', u'tám', u'chín', u'mười', u'mười một', u'mười hai', u'mười ba', u'mười bốn', u'mười lăm', u'mười sáu', u'mười bảy', u'mười tám', u'mười chín') tens = (u'hai mươi', u'ba mươi', u'bốn mươi', u'năm mươi', u'sáu mươi', u'bảy mươi', u'tám mươi', u'chín mươi') denom = ('', u'nghìn', u'triệu', u'tỷ', u'nghìn tỷ', u'trăm nghìn tỷ', 'Quintillion', 'Sextillion', 'Septillion', 'Octillion', 'Nonillion', 'Decillion', 'Undecillion', 'Duodecillion', 'Tredecillion', 'Quattuordecillion', 'Sexdecillion', 'Septendecillion', 'Octodecillion', 'Novemdecillion', 'Vigintillion') class Num2Word_VI(object): def _convert_nn(self, val): if val < 20: return to_19[val] for (dcap, dval) in ((k, 20 + (10 * v)) for (v, k) in enumerate(tens)): if dval + 10 > val: if val % 10: a = u'lăm' if to_19[val % 10] == u'một': a = u'mốt' else: a = to_19[val % 10] if to_19[val % 10] == u'năm': a = u'lăm' return dcap + ' ' + a return dcap def _convert_nnn(self, val): word = '' (mod, rem) = (val % 100, val // 100) if rem > 0: word = to_19[rem] + u' trăm' if mod > 0: word = word + ' ' if mod > 0 and mod < 10: if mod == 5: word = word != '' and word + u'lẻ năm' or word + u'năm' else: word = word != '' and word + u'lẻ ' \ + self._convert_nn(mod) or word + self._convert_nn(mod) if mod >= 10: word = word + self._convert_nn(mod) return word def vietnam_number(self, val): if val < 100: return self._convert_nn(val) if val < 1000: return self._convert_nnn(val) for (didx, dval) in ((v - 1, 1000 ** v) for v in range(len(denom))): if dval > val: mod = 1000 ** didx lval = val // mod r = val - (lval * mod) ret = self._convert_nnn(lval) + u' ' + denom[didx] if 99 >= r > 0: ret = self._convert_nnn(lval) + u' ' + denom[didx] + u' lẻ' if r > 0: ret = ret + ' ' + self.vietnam_number(r) return ret def number_to_text(self, number): number = '%.2f' % number the_list = str(number).split('.') start_word = self.vietnam_number(int(the_list[0])) final_result = start_word if len(the_list) > 1 and int(the_list[1]) > 0: end_word = self.vietnam_number(int(the_list[1])) final_result = final_result + ' phẩy ' + end_word return final_result def to_cardinal(self, number): return self.number_to_text(number) def to_ordinal(self, number): return self.to_cardinal(number) num2words-0.5.14/num2words/utils.py000066400000000000000000000025201473005321200172070ustar00rootroot00000000000000# -*- 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 num2words-0.5.14/requirements-test.txt000066400000000000000000000001011473005321200177670ustar00rootroot00000000000000tox flake8 flake8-copyright isort pep8<1.6 coverage delegator.py num2words-0.5.14/setup.py000066400000000000000000000062031473005321200152510ustar00rootroot00000000000000# -*- 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 import re from io import open from setuptools import find_packages, setup PACKAGE_NAME = "num2words" CLASSIFIERS = [ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: GNU Library or Lesser General Public License ' '(LGPL)', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Topic :: Software Development :: Internationalization', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Software Development :: Localization', 'Topic :: Text Processing :: Linguistic', ] LONG_DESC = open('README.rst', 'rt', encoding="utf-8").read() + '\n\n' + \ open('CHANGES.rst', 'rt', encoding="utf-8").read() def find_version(fname): """Parse file & return version number matching 0.0.1 regex Returns str or raises RuntimeError """ version = '' with open(fname, 'r', encoding="utf-8") as fp: reg = re.compile(r'__version__ = [\'"]([^\'"]*)[\'"]') for line in fp: m = reg.match(line) if m: version = m.group(1) break if not version: raise RuntimeError('Cannot find version information') return version setup( name=PACKAGE_NAME, version=find_version("bin/num2words"), description='Modules to convert numbers to words. Easily extensible.', long_description=LONG_DESC, long_description_content_type="text/markdown", license='LGPL', author='Taro Ogawa ', author_email='tos@users.sourceforge.net', maintainer='Savoir-faire Linux inc.', maintainer_email='support@savoirfairelinux.com', keywords=' number word numbers words convert conversion i18n ' 'localisation localization internationalisation ' 'internationalization', url='https://github.com/savoirfairelinux/num2words', packages=find_packages(exclude=['tests']), test_suite='tests', classifiers=CLASSIFIERS, scripts=['bin/num2words'], install_requires=["docopt>=0.6.2"], tests_require=['delegator.py'], ) num2words-0.5.14/tests/000077500000000000000000000000001473005321200147005ustar00rootroot00000000000000num2words-0.5.14/tests/__init__.py000066400000000000000000000000001473005321200167770ustar00rootroot00000000000000num2words-0.5.14/tests/test_am.py000066400000000000000000000104451473005321200167120ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsAMTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(100, lang='am'), 'መቶ') self.assertEqual(num2words(100000, lang='am'), 'አንድ መቶ ሺህ') self.assertEqual(num2words(101, lang='am'), 'አንድ መቶ አንድ') def test_and_join_199(self): self.assertEqual(num2words(199, lang='am'), 'አንድ መቶ ዘጠና ዘጠኝ') def test_to_ordinal(self): self.assertEqual( num2words(1, lang='am', to='ordinal'), 'አንደኛ' ) self.assertEqual( num2words(13, lang='am', to='ordinal'), 'አሥራ ሦስተኛ' ) self.assertEqual( num2words(22, lang='am', to='ordinal'), 'ሃያ ሁለተኛ' ) self.assertEqual( num2words(10000, lang='am', to='ordinal'), 'አሥር ሺህኛ' ) def test_to_ordinal_num(self): self.assertEqual(num2words(10, lang='am', to='ordinal_num'), '10ኛ') self.assertEqual(num2words(21, lang='am', to='ordinal_num'), '21ኛ') self.assertEqual(num2words(102, lang='am', to='ordinal_num'), '102ኛ') def test_cardinal_for_float_number(self): self.assertEqual(num2words(12.5, lang='am'), 'አሥራ ሁለት ነጥብ አምስት') self.assertEqual(num2words(12.51, lang='am'), 'አሥራ ሁለት ነጥብ አምስት አንድ') self.assertEqual(num2words(12.53, lang='am'), 'አሥራ ሁለት ነጥብ አምስት ሦስት') def test_to_overflow(self): with self.assertRaises(OverflowError): num2words('1000000000000000000000000000000000000000000000000000000' '0000000000000000000000000000000000000000000000000000000' '0000000000000000000000000000000000000000000000000000000' '0000000000000000000000000000000000000000000000000000000' '0000000000000000000000000000000000000000000000000000000' '00000000000000000000000000000000', lang='am') def test_to_currency(self): self.assertEqual( num2words('38.4', lang='am', to='currency', cents=False, currency='ETB'), 'ሠላሳ ስምንት ብር ከ 40 ሳንቲም' ) self.assertEqual( num2words('0', lang='am', to='currency', separator=' እና', cents=True, currency='ETB'), 'ዜሮ ብር እና ዜሮ ሳንቲም' ) self.assertEqual( num2words('1.50', lang='am', to='currency', cents=True, currency='ETB'), 'አንድ ብር ከ አምሳ ሳንቲም' ) def test_to_year(self): self.assertEqual(num2words(1990, lang='am', to='year'), 'አሥራ ዘጠኝ መቶ ዘጠና') self.assertEqual(num2words(5555, lang='am', to='year'), 'አምሳ አምስት መቶ አምሳ አምስት') self.assertEqual(num2words(2017, lang='am', to='year'), 'ሁለት ሺህ አሥራ ሰባት') self.assertEqual(num2words(1066, lang='am', to='year'), 'አንድ ሺህ ስድሳ ስድስት') self.assertEqual(num2words(1865, lang='am', to='year'), 'አሥራ ስምንት መቶ ስድሳ አምስት') num2words-0.5.14/tests/test_ar.py000066400000000000000000000274541473005321200167270ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsARTest(TestCase): def test_default_currency(self): self.assertEqual(num2words(1, to='currency', lang='ar'), 'واحد ريال') self.assertEqual(num2words(2, to='currency', lang='ar'), 'اثنان ريالان') self.assertEqual(num2words(10, to='currency', lang='ar'), 'عشرة ريالات') self.assertEqual(num2words(100, to='currency', lang='ar'), 'مائة ريال') self.assertEqual(num2words(652.12, to='currency', lang='ar'), 'ستمائة و اثنان و خمسون ريالاً و اثنتا عشرة هللة') self.assertEqual(num2words(324, to='currency', lang='ar'), 'ثلاثمائة و أربعة و عشرون ريالاً') self.assertEqual(num2words(2000, to='currency', lang='ar'), 'ألفا ريال') self.assertEqual(num2words(541, to='currency', lang='ar'), 'خمسمائة و واحد و أربعون ريالاً') self.assertEqual(num2words(10000, to='currency', lang='ar'), 'عشرة آلاف ريال') self.assertEqual(num2words(20000.12, to='currency', lang='ar'), 'عشرون ألف ريال و اثنتا عشرة هللة') self.assertEqual(num2words(1000000, to='currency', lang='ar'), 'مليون ريال') val = 'تسعمائة و ثلاثة و عشرون ألفاً و أربعمائة و أحد عشر ريالاً' self.assertEqual(num2words(923411, to='currency', lang='ar'), val) self.assertEqual(num2words(63411, to='currency', lang='ar'), 'ثلاثة و ستون ألفاً و أربعمائة و أحد عشر ريالاً') self.assertEqual(num2words(1000000.99, to='currency', lang='ar'), 'مليون ريال و تسع و تسعون هللة') def test_currency_parm(self): self.assertEqual( num2words(1, to='currency', lang='ar', currency="KWD"), 'واحد دينار') self.assertEqual( num2words(10, to='currency', lang='ar', currency="EGP"), 'عشرة جنيهات') self.assertEqual( num2words(20000.12, to='currency', lang='ar', currency="EGP"), 'عشرون ألف جنيه و اثنتا عشرة قرش') self.assertEqual( num2words(923411, to='currency', lang='ar', currency="SR"), 'تسعمائة و ثلاثة و عشرون ألفاً و أربعمائة و أحد عشر ريالاً') self.assertEqual( num2words(1000000.99, to='currency', lang='ar', currency="KWD"), 'مليون دينار و تسع و تسعون فلس') self.assertEqual( num2words(1000.42, to='currency', lang='ar', currency="TND"), 'ألف دينار و أربعمائة و عشرون مليم') self.assertEqual( num2words(123.21, to='currency', lang='ar', currency="TND"), 'مائة و ثلاثة و عشرون ديناراً و مئتان و عشر مليمات') def test_ordinal(self): self.assertEqual(num2words(1, to='ordinal', lang='ar'), 'اول') self.assertEqual(num2words(2, to='ordinal', lang='ar'), 'ثاني') self.assertEqual(num2words(3, to='ordinal', lang='ar'), 'ثالث') self.assertEqual(num2words(4, to='ordinal', lang='ar'), 'رابع') self.assertEqual(num2words(5, to='ordinal', lang='ar'), 'خامس') self.assertEqual(num2words(6, to='ordinal', lang='ar'), 'سادس') self.assertEqual(num2words(9, to='ordinal', lang='ar'), 'تاسع') self.assertEqual(num2words(20, to='ordinal', lang='ar'), 'عشرون') self.assertEqual(num2words(94, to='ordinal', lang='ar'), 'أربع و تسعون') self.assertEqual(num2words(102, to='ordinal', lang='ar'), 'مائة و اثنان') self.assertEqual( num2words(923411, to='ordinal_num', lang='ar'), 'تسعمائة و ثلاثة و عشرون ألفاً و أربعمائة و أحد عشر') # See https://github.com/savoirfairelinux/num2words/issues/403 self.assertEqual(num2words(23, lang="ar"), 'ثلاثة و عشرون') self.assertEqual(num2words(23, to='ordinal', lang="ar"), 'ثلاث و عشرون') self.assertEqual(num2words(23, lang="ar"), 'ثلاثة و عشرون') def test_cardinal(self): self.assertEqual(num2words(0, to='cardinal', lang='ar'), 'صفر') self.assertEqual(num2words(12, to='cardinal', lang='ar'), 'اثنا عشر') self.assertEqual(num2words(12.3, to='cardinal', lang='ar'), 'اثنا عشر , ثلاثون') self.assertEqual(num2words(12.01, to='cardinal', lang='ar'), 'اثنا عشر , إحدى') self.assertEqual(num2words(12.02, to='cardinal', lang='ar'), 'اثنا عشر , اثنتان') self.assertEqual(num2words(12.03, to='cardinal', lang='ar'), 'اثنا عشر , ثلاث') self.assertEqual(num2words(12.34, to='cardinal', lang='ar'), 'اثنا عشر , أربع و ثلاثون') # Not implemented self.assertEqual(num2words(12.345, to='cardinal', lang='ar'), num2words(12.34, to='cardinal', lang='ar')) self.assertEqual(num2words(-8324, to='cardinal', lang='ar'), 'سالب ثمانية آلاف و ثلاثمائة و أربعة و عشرون') self.assertEqual(num2words(200, to='cardinal', lang='ar'), 'مئتا') self.assertEqual(num2words(700, to='cardinal', lang='ar'), 'سبعمائة') self.assertEqual(num2words(101010, to='cardinal', lang='ar'), 'مائة و ألف ألف و عشرة') self.assertEqual( num2words(3431.12, to='cardinal', lang='ar'), 'ثلاثة آلاف و أربعمائة و واحد و ثلاثون , اثنتا عشرة') self.assertEqual(num2words(431, to='cardinal', lang='ar'), 'أربعمائة و واحد و ثلاثون') self.assertEqual(num2words(94231, to='cardinal', lang='ar'), 'أربعة و تسعون ألفاً و مئتان و واحد و ثلاثون') self.assertEqual(num2words(1431, to='cardinal', lang='ar'), 'ألف و أربعمائة و واحد و ثلاثون') self.assertEqual(num2words(740, to='cardinal', lang='ar'), 'سبعمائة و أربعون') self.assertEqual(num2words(741, to='cardinal', lang='ar'), # 'سبعة مائة و واحد و أربعون' 'سبعمائة و واحد و أربعون' ) self.assertEqual(num2words(262, to='cardinal', lang='ar'), 'مئتان و اثنان و ستون' ) self.assertEqual(num2words(798, to='cardinal', lang='ar'), 'سبعمائة و ثمانية و تسعون' ) self.assertEqual(num2words(710, to='cardinal', lang='ar'), 'سبعمائة و عشرة') self.assertEqual(num2words(711, to='cardinal', lang='ar'), # 'سبعة مائة و إحدى عشر' 'سبعمائة و أحد عشر' ) self.assertEqual(num2words(700, to='cardinal', lang='ar'), 'سبعمائة') self.assertEqual(num2words(701, to='cardinal', lang='ar'), 'سبعمائة و واحد') self.assertEqual( num2words(1258888, to='cardinal', lang='ar'), 'مليون و مئتان و ثمانية و خمسون ألفاً و ثمانمائة و ثمانية و ثمانون' ) self.assertEqual(num2words(1100, to='cardinal', lang='ar'), 'ألف و مائة') self.assertEqual(num2words(1000000521, to='cardinal', lang='ar'), 'مليار و خمسمائة و واحد و عشرون') def test_prefix_and_suffix(self): self.assertEqual(num2words(645, to='currency', lang='ar', prefix="فقط", suffix="لاغير"), 'فقط ستمائة و خمسة و أربعون ريالاً لاغير') def test_year(self): self.assertEqual(num2words(2000, to='year', lang='ar'), 'ألفا') def test_max_numbers(self): for number in 10**51, 10**51 + 2: with self.assertRaises(OverflowError) as context: num2words(number, lang='ar') self.assertTrue('must be less' in str(context.exception)) def test_big_numbers(self): self.assertEqual( num2words(1000000045000000000000003000000002000000300, to='cardinal', lang='ar'), 'تريديسيليون و خمسة و أربعون ديسيليوناً\ و ثلاثة كوينتليونات و ملياران و ثلاثمائة' ) self.assertEqual( num2words(-1000000000000000000000003000000002000000302, to='cardinal', lang='ar'), 'سالب تريديسيليون و ثلاثة كوينتليونات \ و ملياران و ثلاثمائة و اثنان' ) self.assertEqual( num2words(9999999999999999999999999999999999999999999999992, to='cardinal', lang='ar'), 'تسعة كوينتينيليونات و تسعمائة و\ تسعة و تسعون كوادريسيليوناً و تسعمائة و تسعة\ و تسعون تريديسيليوناً و تسعمائة و تسعة و تسعون دوديسيليوناً و تسعمائة\ و تسعة و تسعون أندسيليوناً و تسعمائة و تسعة و تسعون ديسيليوناً\ و تسعمائة و تسعة و تسعون نونيليوناً و تسعمائة و تسعة و تسعون\ أوكتيليوناً و تسعمائة و تسعة و تسعون سبتيليوناً و تسعمائة و تسعة\ و تسعون سكستيليوناً و تسعمائة و تسعة و تسعون كوينتليوناً و تسعمائة و\ تسعة و تسعون كوادريليوناً و تسعمائة و تسعة و تسعون تريليوناً\ و تسعمائة و تسعة و تسعون ملياراً و تسعمائة و تسعة و تسعون مليوناً\ و تسعمائة و تسعة و تسعون ألفاً و تسعمائة و اثنان و تسعون' ) num2words-0.5.14/tests/test_az.py000066400000000000000000000225551473005321200167340ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordAZTest(TestCase): lang = 'az' CARDINAL_TEST_CASES = ( (0, 'sıfır',), (1, 'bir',), (2, 'iki',), (3, 'üç',), (4, 'dörd',), (5, 'beş',), (6, 'altı',), (7, 'yeddi',), (8, 'səkkiz',), (9, 'doqquz',), (10, 'on',), (11, 'on bir',), (20, 'iyirmi',), (22, 'iyirmi iki',), (30, 'otuz',), (33, 'otuz üç',), (40, 'qırx',), (44, 'qırx dörd',), (50, 'əlli',), (55, 'əlli beş',), (60, 'altmış',), (66, 'altmış altı',), (70, 'yetmiş',), (77, 'yetmiş yeddi',), (80, 'səksən',), (88, 'səksən səkkiz',), (90, 'doxsan',), (99, 'doxsan doqquz',), (100, 'yüz',), (200, 'iki yüz',), (678, 'altı yüz yetmiş səkkiz',), (999, 'doqquz yüz doxsan doqquz',), (1000, 'min',), (100_000, 'yüz min',), (328_914, 'üç yüz iyirmi səkkiz min doqquz yüz on dörd',), (1_000_000, 'bir milyon',), (1_000_000_000, 'bir milyard',), (10**12, 'bir trilyon',), (10**15, 'bir katrilyon',), (10**18, 'bir kentilyon',), (10**21, 'bir sekstilyon',), (10**24, 'bir septilyon',), (10**27, 'bir oktilyon',), (10**30, 'bir nonilyon',), (10**33, 'bir desilyon',), (10**36, 'bir undesilyon',), (10**39, 'bir dodesilyon',), (10**42, 'bir tredesilyon',), (10**45, 'bir katordesilyon',), (10**48, 'bir kendesilyon',), (10**51, 'bir seksdesilyon',), (10**54, 'bir septendesilyon',), (10**57, 'bir oktodesilyon',), (10**60, 'bir novemdesilyon',), (10**63, 'bir vigintilyon',), (-0, 'sıfır',), (-1, 'mənfi bir',), (-2, 'mənfi iki',), (-3, 'mənfi üç',), (-4, 'mənfi dörd',), (-5, 'mənfi beş',), (-6, 'mənfi altı',), (-7, 'mənfi yeddi',), (-8, 'mənfi səkkiz',), (-9, 'mənfi doqquz',), (-10, 'mənfi on',), (-11, 'mənfi on bir',), (-20, 'mənfi iyirmi',), (-22, 'mənfi iyirmi iki',), (-30, 'mənfi otuz',), (-33, 'mənfi otuz üç',), (-40, 'mənfi qırx',), (-44, 'mənfi qırx dörd',), (-50, 'mənfi əlli',), (-55, 'mənfi əlli beş',), (-60, 'mənfi altmış',), (-66, 'mənfi altmış altı',), (-70, 'mənfi yetmiş',), (-77, 'mənfi yetmiş yeddi',), (-80, 'mənfi səksən',), (-88, 'mənfi səksən səkkiz',), (-90, 'mənfi doxsan',), (-99, 'mənfi doxsan doqquz',), (-100, 'mənfi yüz',), (-200, 'mənfi iki yüz',), (-678, 'mənfi altı yüz yetmiş səkkiz',), (-999, 'mənfi doqquz yüz doxsan doqquz',), (-1000, 'mənfi min',), (-100_000, 'mənfi yüz min',), (-328_914, 'mənfi üç yüz iyirmi səkkiz min doqquz yüz on dörd',), (-1_000_000, 'mənfi bir milyon',), (-1_000_000_000, 'mənfi bir milyard',), (-10**12, 'mənfi bir trilyon',), (-10**15, 'mənfi bir katrilyon',), (-10**18, 'mənfi bir kentilyon',), (-10**21, 'mənfi bir sekstilyon',), (-10**24, 'mənfi bir septilyon',), (-10**27, 'mənfi bir oktilyon',), (-10**30, 'mənfi bir nonilyon',), (-10**33, 'mənfi bir desilyon',), (-10**36, 'mənfi bir undesilyon',), (-10**39, 'mənfi bir dodesilyon',), (-10**42, 'mənfi bir tredesilyon',), (-10**45, 'mənfi bir katordesilyon',), (-10**48, 'mənfi bir kendesilyon',), (-10**51, 'mənfi bir seksdesilyon',), (-10**54, 'mənfi bir septendesilyon',), (-10**57, 'mənfi bir oktodesilyon',), (-10**60, 'mənfi bir novemdesilyon',), (-10**63, 'mənfi bir vigintilyon'), ) CARDINAL_FRACTION_TEST_CASES = ( (0.2, 'sıfır nöqtə iki',), (0.02, 'sıfır nöqtə sıfır iki',), (0.23, 'sıfır nöqtə iyirmi üç',), (0.0023, 'sıfır nöqtə sıfır sıfır iyirmi üç',), (1.43, 'bir nöqtə qırx üç',), (-0.2, 'mənfi sıfır nöqtə iki',), (-0.02, 'mənfi sıfır nöqtə sıfır iki',), (-0.23, 'mənfi sıfır nöqtə iyirmi üç',), (-0.0023, 'mənfi sıfır nöqtə sıfır sıfır iyirmi üç',), (-1.43, 'mənfi bir nöqtə qırx üç',), ) ORDINAL_TEST_CASES = ( (0, 'sıfırıncı',), (1, 'birinci',), (2, 'ikinci',), (3, 'üçüncü',), (4, 'dördüncü',), (5, 'beşinci',), (6, 'altıncı',), (7, 'yeddinci',), (8, 'səkkizinci',), (9, 'doqquzuncu',), (10, 'onuncu',), (11, 'on birinci',), (20, 'iyirminci',), (22, 'iyirmi ikinci',), (30, 'otuzuncu',), (33, 'otuz üçüncü',), (40, 'qırxıncı',), (44, 'qırx dördüncü',), (50, 'əllinci',), (55, 'əlli beşinci',), (60, 'altmışıncı',), (66, 'altmış altıncı',), (70, 'yetmişinci',), (77, 'yetmiş yeddinci',), (80, 'səksəninci',), (88, 'səksən səkkizinci',), (90, 'doxsanıncı',), (99, 'doxsan doqquzuncu',), (100, 'yüzüncü',), (1000, 'mininci',), (328_914, 'üç yüz iyirmi səkkiz min doqquz yüz on dördüncü',), (1_000_000, 'bir milyonuncu'), ) ORDINAL_NUM_TEST_CASES = ( (0, '0-cı',), (1, '1-ci',), (2, '2-ci',), (3, '3-cü',), (4, '4-cü',), (5, '5-ci',), (6, '6-cı',), (7, '7-ci',), (8, '8-ci',), (9, '9-cu',), (10, '10-cu',), (11, '11-ci',), (20, '20-ci',), (22, '22-ci',), (30, '30-cu',), (33, '33-cü',), (40, '40-cı',), (44, '44-cü',), (50, '50-ci',), (55, '55-ci',), (60, '60-cı',), (66, '66-cı',), (70, '70-ci',), (77, '77-ci',), (80, '80-ci',), (88, '88-ci',), (90, '90-cı',), (99, '99-cu',), (100, '100-cü',), (1000, '1000-ci',), (328_914, '328914-cü',), (1_000_000, '1000000-cu'), ) YEAR_TEST_CASES = ( (167, 'yüz altmış yeddi'), (1552, 'min beş yüz əlli iki'), (1881, 'min səkkiz yüz səksən bir'), (2022, 'iki min iyirmi iki'), (-1, 'e.ə. bir'), (-500, 'e.ə. beş yüz'), (-5000, 'e.ə. beş min'), ) CURRENCY_TEST_CASES = ( (0.0, 'sıfır manat, sıfır qəpik'), (0.01, 'sıfır manat, bir qəpik'), (0.1, 'sıfır manat, on qəpik'), (1.5, 'bir manat, əlli qəpik'), (1.94, 'bir manat, doxsan dörd qəpik'), (17.82, 'on yeddi manat, səksən iki qəpik'), ) def test_cardinal(self): """Test cardinal conversion for integer numbers.""" for number, expected in self.CARDINAL_TEST_CASES: actual = num2words(number, lang=self.lang, to='cardinal') self.assertEqual(actual, expected) def test_cardinal_fracion(self): """Test cardinal conversion for numbers with fraction.""" for number, expected in self.CARDINAL_FRACTION_TEST_CASES: actual = num2words(number, lang=self.lang, to='cardinal') self.assertEqual(actual, expected) def test_ordinal(self): """Test ordinal conversion.""" for number, expected in self.ORDINAL_TEST_CASES: actual = num2words(number, lang=self.lang, to='ordinal') self.assertEqual(actual, expected) def test_ordinal_num(self): """Test 'ordinal_num' conversion.""" for number, expected in self.ORDINAL_NUM_TEST_CASES: actual = num2words(number, lang=self.lang, to='ordinal_num') self.assertEqual(actual, expected) def test_year(self): """Test year conversion.""" for number, expected in self.YEAR_TEST_CASES: actual = num2words(number, lang=self.lang, to='year') self.assertEqual(actual, expected) def test_currency(self): """Test currency conversion.""" for number, expected in self.CURRENCY_TEST_CASES: actual = num2words( number, lang=self.lang, currency='AZN', to='currency') self.assertEqual(actual, expected) num2words-0.5.14/tests/test_base.py000066400000000000000000000056101473005321200172250ustar00rootroot00000000000000# -*- 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 decimal import Decimal from unittest import TestCase from num2words.base import Num2Word_Base class Num2WordBaseTest(TestCase): @classmethod def setUpClass(cls): super(Num2WordBaseTest, cls).setUpClass() cls.base = Num2Word_Base() def test_to_currency_not_implemented(self): with self.assertRaises(NotImplementedError): self.base.to_currency(Decimal('1.00'), currency='EUR') def test_error_to_cardinal_float(self): from num2words.base import Num2Word_Base self.base = Num2Word_Base() with self.assertRaises(TypeError): self.base.to_cardinal_float("a") def test_error_merge(self): from num2words.base import Num2Word_Base self.base = Num2Word_Base() with self.assertRaises(NotImplementedError): self.base.merge(2, 3) def test_is_title(self): from num2words.base import Num2Word_Base self.base = Num2Word_Base() self.assertEqual( self.base.title("one"), "one" ) self.base.is_title = True self.assertEqual( self.base.title("one"), "One" ) self.base.exclude_title.append('one') self.assertEqual( self.base.title("one"), "one" ) def test_set_high_numwords_not_implemented(self): with self.assertRaises(NotImplementedError): self.base.set_high_numwords() def test_to_ordinal_num(self): from num2words.base import Num2Word_Base self.base = Num2Word_Base() self.assertEqual( self.base.to_ordinal_num(1), 1 ) self.assertEqual( self.base.to_ordinal_num(100), 100 ) self.assertEqual( self.base.to_ordinal_num(1000), 1000 ) def test_pluralize_not_implemented(self): with self.assertRaises(NotImplementedError): self.base.pluralize(n=None, forms=None) num2words-0.5.14/tests/test_be.py000066400000000000000000000434571473005321200167140ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2023, Sergei Ruzki/Ivan Shakh 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 unittest import TestCase from num2words import num2words class Num2WordsBYTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(100, lang="be"), "сто") self.assertEqual(num2words(101, lang="be"), "сто адзін") self.assertEqual(num2words(110, lang="be"), "сто дзесяць") self.assertEqual(num2words(115, lang="be"), "сто пятнаццаць") self.assertEqual(num2words(123, lang="be"), "сто дваццаць тры") self.assertEqual(num2words(1000, lang="be"), "адна тысяча") self.assertEqual(num2words(1001, lang="be"), "адна тысяча адзін") self.assertEqual(num2words(2012, lang="be"), "дзве тысячы дванаццаць") self.assertEqual( num2words(12519.85, lang="be"), "дванаццаць тысяч пяцьсот дзевятнаццаць коска восемдзесят пяць", ) self.assertEqual( num2words(1234567890, lang="be"), "адзін мільярд дзвесце трыццаць чатыры мільёны пяцьсот " "шэсцьдзясят сем тысяч восемсот дзевяноста", ) self.assertEqual( num2words(461407892039002157189883901676, lang="be"), "чатырыста шэсцьдзясят адзін " "актыльён чатырыста сем сэптыльёнаў восемсот дзевяноста " "два секстыльёны трыццаць дзевяць квінтыльёнаў два квадрыльёны " "сто пяцьдзясят сем трыльёнаў сто восемдзесят дзевяць мільярдаў " "восемсот восемдзесят тры мільёны дзевяцьсот адна тысяча " "шэсцьсот семдзесят шэсць", ) self.assertEqual( num2words(94234693663034822824384220291, lang="be"), "дзевяноста чатыры актыльёны " "дзвесце трыццаць чатыры сэптыльёны шэсцьсот дзевяноста тры " "секстыльёны шэсцьсот шэсцьдзясят тры квінтыльёны трыццаць " "чатыры квадрыльёны восемсот дваццаць два трыльёны восемсот " "дваццаць чатыры мільярды трыста восемдзесят чатыры мільёны " "дзвесце дваццаць тысяч дзвесце дзевяноста адзін", ) self.assertEqual(num2words(5, lang="be"), "пяць") self.assertEqual(num2words(15, lang="be"), "пятнаццаць") self.assertEqual(num2words(154, lang="be"), "сто пяцьдзясят чатыры") self.assertEqual( num2words(1135, lang="be"), "адна тысяча сто трыццаць пяць" ) self.assertEqual( num2words(418531, lang="be"), "чатырыста васямнаццаць тысяч пяцьсот трыццаць адзін", ) self.assertEqual( num2words(1000139, lang="be"), "адзін мільён сто трыццаць дзевяць" ) self.assertEqual(num2words(-1, lang="be"), "мінус адзін") self.assertEqual(num2words(-15, lang="be"), "мінус пятнаццаць") self.assertEqual(num2words(-100, lang="be"), "мінус сто") def test_floating_point(self): self.assertEqual(num2words(5.2, lang="be"), "пяць коска два") self.assertEqual(num2words(10.02, lang="be"), "дзесяць коска нуль два") self.assertEqual( num2words(15.007, lang="be"), "пятнаццаць коска нуль нуль сем" ) self.assertEqual( num2words(561.42, lang="be"), "пяцьсот шэсцьдзясят адзін коска сорак два", ) self.assertEqual( num2words(561.0, lang="be"), "пяцьсот шэсцьдзясят адзін коска нуль" ) def test_to_ordinal(self): self.assertEqual(num2words(1, lang="be", to="ordinal"), "першы") self.assertEqual(num2words(5, lang="be", to="ordinal"), "пяты") self.assertEqual(num2words(6, lang="be", to="ordinal"), "шосты") self.assertEqual(num2words(10, lang="be", to="ordinal"), "дзясяты") self.assertEqual(num2words(13, lang="be", to="ordinal"), "трынаццаты") self.assertEqual(num2words(20, lang="be", to="ordinal"), "дваццаты") self.assertEqual( num2words(23, lang="be", to="ordinal"), "дваццаць трэці" ) self.assertEqual( num2words(23, lang="be", to="ordinal", gender="f"), "дваццаць трэцяя", ) self.assertEqual( num2words(23, lang="be", to="ordinal", gender=True), "дваццаць трэцяя", ) self.assertEqual( num2words(23, lang="be", to="ordinal", gender="n"), "дваццаць трэцяе", ) self.assertEqual( num2words(46, lang="be", to="ordinal", gender="m"), "сорак шосты", ) self.assertEqual(num2words(40, lang="be", to="ordinal"), "саракавы") self.assertEqual( num2words(61, lang="be", to="ordinal"), "шэсцьдзясят першы" ) self.assertEqual(num2words(70, lang="be", to="ordinal"), "сямідзясяты") self.assertEqual(num2words(100, lang="be", to="ordinal"), "соты") self.assertEqual( num2words(136, lang="be", to="ordinal"), "сто трыццаць шосты" ) self.assertEqual(num2words(500, lang="be", to="ordinal"), "пяцісоты") self.assertEqual( num2words(500, lang="be", to="ordinal", gender="f"), "пяцісотая" ) self.assertEqual( num2words(500, lang="be", to="ordinal", gender="n"), "пяцісотае" ) self.assertEqual(num2words(1000, lang="be", to="ordinal"), "тысячны") self.assertEqual( num2words(1000, lang="be", to="ordinal", gender="f"), "тысячная" ) self.assertEqual( num2words(1000, lang="be", to="ordinal", gender="n"), "тысячнае" ) self.assertEqual( num2words(1001, lang="be", to="ordinal"), "тысяча першы" ) self.assertEqual( num2words(3000, lang="be", to="ordinal"), "трохтысячны" ) self.assertEqual( num2words(10000, lang="be", to="ordinal"), "дзесяцітысячны" ) self.assertEqual( num2words(30000, lang="be", to="ordinal"), "трыццацітысячны" ) self.assertEqual( num2words(42000, lang="be", to="ordinal"), "саракадвухтысячны" ) self.assertEqual( num2words(75000, lang="be", to="ordinal"), "сямідзесяціпяцітысячны" ) self.assertEqual( num2words(1000000, lang="be", to="ordinal"), "мільённы" ) self.assertEqual( num2words(30000000, lang="be", to="ordinal"), "трыццацімільённы" ) self.assertEqual( num2words(1000000000, lang="be", to="ordinal"), "мільярдны" ) self.assertEqual( num2words(3000000000, lang="be", to="ordinal"), "трохмільярдны" ) self.assertEqual( num2words(43000000000, lang="be", to="ordinal"), "саракатрохмільярдны", ) self.assertEqual( num2words(333000000000, lang="be", to="ordinal"), "трыстатрыццацітрохмільярдны", ) def test_to_currency(self): self.assertEqual( num2words(1.0, lang="be", to="currency", currency="EUR"), "адзін еўра, нуль цэнтаў", ) self.assertEqual( num2words(1.0, lang="be", to="currency", currency="RUB"), "адзін расійскі рубель, нуль капеек", ) self.assertEqual( num2words(1.0, lang="be", to="currency", currency="BYN"), "адзін беларускі рубель, нуль капеек", ) self.assertEqual( num2words(1.0, lang="be", to="currency", currency="UAH"), "адна грыўна, нуль капеек", ) self.assertEqual( num2words(1234.56, lang="be", to="currency", currency="EUR"), "адна тысяча дзвесце трыццаць чатыры еўра, " "пяцьдзясят шэсць цэнтаў", ) self.assertEqual( num2words(1234.56, lang="be", to="currency", currency="RUB"), "адна тысяча дзвесце трыццаць чатыры расійскія рублі, " "пяцьдзясят шэсць капеек", ) self.assertEqual( num2words(1234.56, lang="be", to="currency", currency="BYN"), "адна тысяча дзвесце трыццаць чатыры беларускія рублі, " "пяцьдзясят шэсць капеек", ) self.assertEqual( num2words(1234.56, lang="be", to="currency", currency="UAH"), "адна тысяча дзвесце трыццаць чатыры грыўны, " "пяцьдзясят шэсць капеек", ) self.assertEqual( num2words( 10111, lang="be", to="currency", currency="EUR", separator=" і" ), "сто адзін еўра і адзінаццаць цэнтаў", ) self.assertEqual( num2words( 10111, lang="be", to="currency", currency="RUB", separator=" і" ), "сто адзін расійскі рубель і адзінаццаць капеек", ) self.assertEqual( num2words( 10111, lang="be", to="currency", currency="BYN", separator=" і" ), "сто адзін беларускі рубель і адзінаццаць капеек", ) self.assertEqual( num2words( 10111, lang="be", to="currency", currency="UAH", separator=" і" ), "сто адна грыўна і адзінаццаць капеек", ) self.assertEqual( num2words( 10121, lang="be", to="currency", currency="EUR", separator=" і" ), "сто адзін еўра і дваццаць адзін цэнт", ) self.assertEqual( num2words( 10121, lang="be", to="currency", currency="RUB", separator=" і" ), "сто адзін расійскі рубель і дваццаць адна капейка", ) self.assertEqual( num2words( 10121, lang="be", to="currency", currency="BYN", separator=" і" ), "сто адзін беларускі рубель і дваццаць адна капейка", ) self.assertEqual( num2words( 10121, lang="be", to="currency", currency="UAH", separator=" і" ), "сто адна грыўна і дваццаць адна капейка", ) self.assertEqual( num2words( 10122, lang="be", to="currency", currency="EUR", separator=" і" ), "сто адзін еўра і дваццаць два цэнты", ) self.assertEqual( num2words( 10122, lang="be", to="currency", currency="RUB", separator=" і" ), "сто адзін расійскі рубель і дваццаць дзве капейкі", ) self.assertEqual( num2words( 10122, lang="be", to="currency", currency="BYN", separator=" і" ), "сто адзін беларускі рубель і дваццаць дзве капейкі", ) self.assertEqual( num2words( 10122, lang="be", to="currency", currency="UAH", separator=" і" ), "сто адна грыўна і дваццаць дзве капейкі", ) self.assertEqual( num2words( 10122, lang="be", to="currency", currency="KZT", separator=" і" ), "сто адзін тэнге і дваццаць два тыйіны", ) self.assertEqual( num2words( -1251985, lang="be", to="currency", currency="EUR", cents=False ), "мінус дванаццаць тысяч пяцьсот дзевятнаццаць еўра, 85 цэнтаў", ) self.assertEqual( num2words( -1251985, lang="be", to="currency", currency="RUB", cents=False ), "мінус дванаццаць тысяч пяцьсот дзевятнаццаць " "расійскіх рублёў, 85 капеек", ) self.assertEqual( num2words( -1251985, lang="be", to="currency", currency="BYN", cents=False ), "мінус дванаццаць тысяч пяцьсот дзевятнаццаць " "беларускіх рублёў, 85 капеек", ) self.assertEqual( num2words( -1251985, lang="be", to="currency", currency="UAH", cents=False ), "мінус дванаццаць тысяч пяцьсот дзевятнаццаць грыўнаў, 85 капеек", ) self.assertEqual( num2words( "38.4", lang="be", to="currency", separator=" і", cents=False, currency="EUR", ), "трыццаць восем еўра і 40 цэнтаў", ) self.assertEqual( num2words( "38.4", lang="be", to="currency", separator=" і", cents=False, currency="RUB", ), "трыццаць восем расійскіх рублёў і 40 капеек", ) self.assertEqual( num2words( "38.4", lang="be", to="currency", separator=" і", cents=False, currency="UAH", ), "трыццаць восем грыўнаў і 40 капеек", ) self.assertEqual( num2words("1230.56", lang="be", to="currency", currency="USD"), "адна тысяча дзвесце трыццаць долараў, пяцьдзясят шэсць цэнтаў", ) self.assertEqual( num2words("1231.56", lang="be", to="currency", currency="USD"), "адна тысяча дзвесце трыццаць адзін долар, " "пяцьдзясят шэсць цэнтаў", ) self.assertEqual( num2words("1234.56", lang="be", to="currency", currency="USD"), "адна тысяча дзвесце трыццаць чатыры долары, пяцьдзясят шэсць " "цэнтаў", ) self.assertEqual( num2words( 10122, lang="be", to="currency", currency="UZS", separator=" і" ), "сто адзін сум і дваццаць два тыйіны", ) self.assertEqual( num2words(1.0, lang="be", to="currency", currency="PLN"), "адзін злоты, нуль грошаў", ) self.assertEqual( num2words(23.40, lang="be", to="currency", currency="PLN"), "дваццаць тры злотых, сорак грошаў", ) self.assertEqual( num2words(9999.39, lang="be", to="currency", currency="PLN"), "дзевяць тысяч дзевяцьсот дзевяноста дзевяць злотых, " "трыццаць дзевяць грошаў", ) num2words-0.5.14/tests/test_bn.py000066400000000000000000000731031473005321200167140ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Author: Mehedi Hasan Khondoker # Email: mehedihasankhondoker [at] gmail.com # Copyright (c) 2024, Mehedi Hasan Khondoker. All Rights Reserved. # This library is build for Bangladesh format Number to Word conversion. # You are welcome as contributor to the library. # 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. from __future__ import unicode_literals from decimal import Decimal from unittest import TestCase from num2words import num2words from num2words.lang_BN import Num2Word_BN, NumberTooLargeError class Num2WordsBNTest(TestCase): maxDiff = None def test_negative(self): self.assertEqual(num2words(-1, lang="bn"), u'এক') def test_0(self): self.assertEqual(num2words(0, lang="bn"), u'শূন্য') def test_1_to_10(self): self.assertEqual(num2words(1, lang="bn"), u'এক') self.assertEqual(num2words(2, lang="bn"), u'দুই') self.assertEqual(num2words(7, lang="bn"), u'সাত') self.assertEqual(num2words(10, lang="bn"), u'দশ') def test_11_to_19(self): self.assertEqual(num2words(11, lang="bn"), u'এগারো') self.assertEqual(num2words(13, lang="bn"), u'তেরো') self.assertEqual(num2words(15, lang="bn"), u'পনের') self.assertEqual(num2words(16, lang="bn"), u'ষোল') self.assertEqual(num2words(19, lang="bn"), u'উনিশ') def test_20_to_99(self): self.assertEqual(num2words(20, lang="bn"), u'বিশ') self.assertEqual(num2words(23, lang="bn"), u'তেইশ') self.assertEqual(num2words(28, lang="bn"), u'আটাশ') self.assertEqual(num2words(31, lang="bn"), u'একত্রিশ') self.assertEqual(num2words(40, lang="bn"), u'চল্লিশ') self.assertEqual(num2words(66, lang="bn"), u'ছিষট্টি') self.assertEqual(num2words(92, lang="bn"), u'বিরানব্বই') def test_100_to_999(self): self.assertEqual(num2words(100, lang="bn"), u'একশত') self.assertEqual(num2words(111, lang="bn"), u'একশত এগারো') self.assertEqual(num2words(150, lang="bn"), u'একশত পঞ্চাশ') self.assertEqual(num2words(196, lang="bn"), u'একশত ছিয়ানব্বই') self.assertEqual(num2words(200, lang="bn"), u'দুইশত') self.assertEqual(num2words(210, lang="bn"), u'দুইশত দশ') self.assertEqual(num2words(701, lang="bn"), u'সাতশত এক') self.assertEqual(num2words(999, lang="bn"), u'নয়শত নিরানব্বই') def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang="bn"), u'এক হাজার') self.assertEqual(num2words(1001, lang="bn"), u'এক হাজার এক') self.assertEqual(num2words(1002, lang="bn"), u'এক হাজার দুই') self.assertEqual(num2words(1010, lang="bn"), u'এক হাজার দশ') self.assertEqual(num2words(1110, lang="bn"), u'এক হাজার একশত দশ') self.assertEqual(num2words(1111, lang="bn"), u'এক হাজার একশত এগারো') self.assertEqual(num2words(1500, lang="bn"), u'এক হাজার পাঁচশত') self.assertEqual(num2words(2000, lang="bn"), u'দুই হাজার') self.assertEqual(num2words(2042, lang="bn"), u'দুই হাজার বিয়াল্লিশ') self.assertEqual(num2words(3000, lang="bn"), u'তিন হাজার') self.assertEqual(num2words(3301, lang="bn"), u'তিন হাজার তিনশত এক') self.assertEqual(num2words(3108, lang="bn"), u'তিন হাজার একশত আট') self.assertEqual(num2words(6870, lang="bn"), u'ছয় হাজার আটশত সত্তর') self.assertEqual(num2words(7378, lang="bn"), u'সাত হাজার তিনশত আটাত্তর') self.assertEqual(num2words(9999, lang="bn"), u'নয় হাজার নয়শত নিরানব্বই') def test_10000_to_99999(self): self.assertEqual(num2words(10000, lang="bn"), u'দশ হাজার') self.assertEqual(num2words(10501, lang="bn"), u'দশ হাজার পাঁচশত এক') self.assertEqual(num2words(10999, lang="bn"), u'দশ হাজার নয়শত নিরানব্বই') self.assertEqual(num2words(13000, lang="bn"), u'তেরো হাজার') self.assertEqual(num2words(15333, lang="bn"), u'পনের হাজার তিনশত তেত্রিশ') self.assertEqual(num2words(21111, lang="bn"), u'একুশ হাজার একশত এগারো') self.assertEqual(num2words(21003, lang="bn"), u'একুশ হাজার তিন') self.assertEqual(num2words(25020, lang="bn"), u'পঁচিশ হাজার বিশ') self.assertEqual(num2words(68700, lang="bn"), u'আটষট্টি হাজার সাতশত') self.assertEqual(num2words(73781, lang="bn"), u'তিয়াত্তর হাজার সাতশত একাশি') self.assertEqual(num2words(99999, lang="bn"), u'নিরানব্বই হাজার নয়শত নিরানব্বই') def test_100000_to_999999(self): self.assertEqual(num2words(100000, lang="bn"), u'এক লাখ') self.assertEqual(num2words('100000', lang="bn"), u'এক লাখ') self.assertEqual(num2words(199999, lang="bn"), u'এক লাখ নিরানব্বই হাজার নয়শত নিরানব্বই') self.assertEqual(num2words(110000, lang="bn"), u'এক লাখ দশ হাজার') self.assertEqual(num2words(150010, lang="bn"), u'এক লাখ পঞ্চাশ হাজার দশ') self.assertEqual(num2words('200200', lang="bn"), u'দুই লাখ দুইশত') self.assertEqual(num2words(737812, lang="bn"), u'সাত লাখ সাতত্রিশ হাজার আটশত বারো') self.assertEqual(num2words('999999', lang="bn"), u'নয় লাখ নিরানব্বই হাজার নয়শত নিরানব্বই') def test_1000000_to_9999999999999999(self): self.assertEqual(num2words(1000000, lang="bn"), u'দশ লাখ') self.assertEqual(num2words(20000000, lang="bn"), u'দুই কোটি') self.assertEqual(num2words(300000000, lang="bn"), u'ত্রিশ কোটি') self.assertEqual(num2words(4000000000, lang="bn"), u'চারশত কোটি') self.assertEqual(num2words(50000000000, lang="bn"), u'পাঁচ হাজার কোটি') self.assertEqual(num2words(600000000000, lang="bn"), u'ষাট হাজার কোটি') self.assertEqual(num2words(7000000000000, lang="bn"), u'সাত লাখ কোটি') self.assertEqual(num2words(80000000000000, lang="bn"), u'আশি লাখ কোটি') self.assertEqual(num2words (900000000000000, lang="bn"), u'নয় কোটি কোটি') self.assertEqual(num2words(999999999999999, lang="bn"), u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই') # noqa: E501 self.assertEqual(num2words(9999999999999999, lang="bn"), u'নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই') # noqa: E501 def test_dosomik_0_to_999999999999999999(self): self.assertEqual(num2words(0.56, lang="bn"), u'শূন্য দশমিক পাঁচ ছয়') self.assertEqual(num2words(1.11, lang="bn"), u'এক দশমিক এক এক') self.assertEqual(num2words(2.66, lang="bn"), u'দুই দশমিক ছয় ছয়') self.assertEqual(num2words(7.68, lang="bn"), u'সাত দশমিক ছয় আট') self.assertEqual(num2words('10.35', lang="bn"), u'দশ দশমিক তিন পাঁচ') self.assertEqual(num2words('11.47', lang="bn"), u'এগারো দশমিক চার সাত') self.assertEqual(num2words(13.69, lang="bn"), u'তেরো দশমিক ছয় নয়') self.assertEqual(num2words(15.96, lang="bn"), u'পনের দশমিক নয় ছয়') self.assertEqual(num2words(16.9999, lang="bn"), u'ষোল দশমিক নয় নয় নয় নয়') self.assertEqual(num2words(19.56587, lang="bn"), u'উনিশ দশমিক পাঁচ ছয় পাঁচ আট সাত') self.assertEqual(num2words(31.31, lang="bn"), u'একত্রিশ দশমিক তিন এক') self.assertEqual(num2words(40.85, lang="bn"), u'চল্লিশ দশমিক আট পাঁচ') self.assertEqual(num2words(66.66, lang="bn"), u'ছিষট্টি দশমিক ছয় ছয়') self.assertEqual(num2words(92.978, lang="bn"), u'বিরানব্বই দশমিক নয় সাত আট') self.assertEqual(num2words(1000001.10, lang="bn"), u'দশ লাখ এক দশমিক এক') self.assertEqual(num2words(20000000.22, lang="bn"), u'দুই কোটি দশমিক দুই দুই') self.assertEqual(num2words(300030000.33, lang="bn"), u'ত্রিশ কোটি ত্রিশ হাজার দশমিক তিন তিন') self.assertEqual(num2words('4004000444.44', lang="bn"), u'চারশত কোটি চল্লিশ লাখ চারশত চৌচল্লিশ দশমিক চার চার') self.assertEqual(num2words(50000000001.50, lang="bn"), u'পাঁচ হাজার কোটি এক দশমিক পাঁচ') self.assertEqual(num2words(600000000600.66, lang="bn"), u'ষাট হাজার কোটি ছয়শত দশমিক ছয় ছয়') self.assertEqual(num2words(7000000000000.77, lang="bn"), u'সাত লাখ কোটি দশমিক সাত সাত') self.assertEqual(num2words(80000000000888.88, lang="bn"), u'আশি লাখ কোটি আটশত আটাশি দশমিক আট আট') self.assertEqual(num2words(900000000000000.9, lang="bn"), u'নয় কোটি কোটি দশমিক নয়') self.assertEqual(num2words(999999999999999.9, lang="bn"), u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়') # noqa: E501 self.assertEqual(num2words(9999999999999999.99, lang="bn"), u'একশত কোটি কোটি') self.assertEqual(num2words(99999999999999999.99, lang="bn"), u'এক হাজার কোটি কোটি') self.assertEqual(num2words('999999999999999999.9', lang="bn"), u'নয় হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়') # noqa: E501 def test_to_currency(self): n = Num2Word_BN() self.assertEqual(n.to_currency(20.0), u'বিশ টাকা') self.assertEqual(n.to_currency(20.50), u'বিশ টাকা পঞ্চাশ পয়সা') self.assertEqual(n.to_currency(33.51), u'তেত্রিশ টাকা একান্ন পয়সা') self.assertEqual(n.to_currency(99.99), u'নিরানব্বই টাকা নিরানব্বই পয়সা') self.assertEqual(n.to_currency(10000.1), u'দশ হাজার টাকা দশ পয়সা') self.assertEqual(n.to_currency(555555.50), u'পাঁচ লাখ পঞ্চান্ন হাজার পাঁচশত পঞ্চান্ন টাকা পঞ্চাশ পয়সা') # noqa: E501 self.assertEqual(n.to_currency(6666676), u'ছিষট্টি লাখ ছিষট্টি হাজার ছয়শত ছিয়াত্তর টাকা') self.assertEqual(n.to_currency(777777777), u'সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত সাতাত্তর টাকা') # noqa: E501 self.assertEqual(n.to_currency(7777777778), u'সাতশত সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত আটাত্তর টাকা') # noqa: E501 self.assertEqual(n.to_currency(97777777778), u'নয় হাজার সাতশত সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত আটাত্তর টাকা') # noqa: E501 self.assertEqual(n.to_currency(977777777781), u'সাতানব্বই হাজার সাতশত সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত একাশি টাকা') # noqa: E501 self.assertEqual(n.to_currency(9777777779781), u'নয় লাখ সাতাত্তর হাজার সাতশত সাতাত্তর কোটি সাতাত্তর লাখ উনআশি হাজার সাতশত একাশি টাকা') # noqa: E501 def test_to_cardinal(self): n = Num2Word_BN() self.assertEqual(n.to_cardinal(0.56), u'শূন্য দশমিক পাঁচ ছয়') self.assertEqual(n.to_cardinal(1.11), u'এক দশমিক এক এক') self.assertEqual(n.to_cardinal(2.66), u'দুই দশমিক ছয় ছয়') self.assertEqual(n.to_cardinal(7.68), u'সাত দশমিক ছয় আট') self.assertEqual(n.to_cardinal('10.35'), u'দশ দশমিক তিন পাঁচ') self.assertEqual(n.to_cardinal('11.47'), u'এগারো দশমিক চার সাত') self.assertEqual(n.to_cardinal(13.69), u'তেরো দশমিক ছয় নয়') self.assertEqual(n.to_cardinal(15.96), u'পনের দশমিক নয় ছয়') self.assertEqual(n.to_cardinal(16.9999), u'ষোল দশমিক নয় নয় নয় নয়') self.assertEqual(n.to_cardinal(19.56587), u'উনিশ দশমিক পাঁচ ছয় পাঁচ আট সাত') self.assertEqual(n.to_cardinal(31.31), u'একত্রিশ দশমিক তিন এক') self.assertEqual(n.to_cardinal(40.85), u'চল্লিশ দশমিক আট পাঁচ') self.assertEqual(n.to_cardinal(66.66), u'ছিষট্টি দশমিক ছয় ছয়') self.assertEqual(n.to_cardinal(92.978), u'বিরানব্বই দশমিক নয় সাত আট') self.assertEqual(n.to_cardinal(1000001.10), u'দশ লাখ এক দশমিক এক') self.assertEqual(n.to_cardinal(20000000.22), u'দুই কোটি দশমিক দুই দুই') self.assertEqual(n.to_cardinal(300030000.33), u'ত্রিশ কোটি ত্রিশ হাজার দশমিক তিন তিন') self.assertEqual(n.to_cardinal('4004000444.44'), u'চারশত কোটি চল্লিশ লাখ চারশত চৌচল্লিশ দশমিক চার চার') self.assertEqual(n.to_cardinal(50000000001.50), u'পাঁচ হাজার কোটি এক দশমিক পাঁচ') self.assertEqual(n.to_cardinal(600000000600.66), u'ষাট হাজার কোটি ছয়শত দশমিক ছয় ছয়') self.assertEqual(n.to_cardinal(7000000000000.77), u'সাত লাখ কোটি দশমিক সাত সাত') self.assertEqual(n.to_cardinal(80000000000888.88), u'আশি লাখ কোটি আটশত আটাশি দশমিক আট আট') self.assertEqual(n.to_cardinal(900000000000000.9), u'নয় কোটি কোটি দশমিক নয়') self.assertEqual(n.to_cardinal(999999999999999.9), u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়') # noqa: E501 self.assertEqual(n.to_cardinal(9999999999999999.99), u'একশত কোটি কোটি') self.assertEqual(n.to_cardinal(99999999999999999.99), u'এক হাজার কোটি কোটি') self.assertEqual(n.to_cardinal('999999999999999999.99'), u'নয় হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয় নয়') # noqa: E501 def test_to_ordinal(self): n = Num2Word_BN() self.assertEqual(n.to_ordinal(0.56), u'শূন্য দশমিক পাঁচ ছয়') self.assertEqual(n.to_ordinal(1.11), u'এক দশমিক এক এক') self.assertEqual(n.to_ordinal(2.66), u'দুই দশমিক ছয় ছয়') self.assertEqual(n.to_ordinal(7.68), u'সাত দশমিক ছয় আট') self.assertEqual(n.to_ordinal('10.35'), u'দশ দশমিক তিন পাঁচ') self.assertEqual(n.to_ordinal('11.47'), u'এগারো দশমিক চার সাত') self.assertEqual(n.to_ordinal(13.69), u'তেরো দশমিক ছয় নয়') self.assertEqual(n.to_ordinal(15.96), u'পনের দশমিক নয় ছয়') self.assertEqual(n.to_ordinal(16.9999), u'ষোল দশমিক নয় নয় নয় নয়') self.assertEqual(n.to_ordinal(19.56587), u'উনিশ দশমিক পাঁচ ছয় পাঁচ আট সাত') self.assertEqual(n.to_ordinal(31.31), u'একত্রিশ দশমিক তিন এক') self.assertEqual(n.to_ordinal(40.85), u'চল্লিশ দশমিক আট পাঁচ') self.assertEqual(n.to_ordinal(66.66), u'ছিষট্টি দশমিক ছয় ছয়') self.assertEqual(n.to_ordinal(92.978), u'বিরানব্বই দশমিক নয় সাত আট') self.assertEqual(n.to_ordinal(1000001.10), u'দশ লাখ এক দশমিক এক') self.assertEqual(n.to_ordinal(20000000.22), u'দুই কোটি দশমিক দুই দুই') self.assertEqual(n.to_ordinal(300030000.33), u'ত্রিশ কোটি ত্রিশ হাজার দশমিক তিন তিন') self.assertEqual(n.to_ordinal('4004000444.44'), u'চারশত কোটি চল্লিশ লাখ চারশত চৌচল্লিশ দশমিক চার চার') self.assertEqual(n.to_ordinal(50000000001.50), u'পাঁচ হাজার কোটি এক দশমিক পাঁচ') self.assertEqual(n.to_ordinal(600000000600.66), u'ষাট হাজার কোটি ছয়শত দশমিক ছয় ছয়') self.assertEqual(n.to_ordinal(7000000000000.77), u'সাত লাখ কোটি দশমিক সাত সাত') self.assertEqual(n.to_ordinal(80000000000888.88), u'আশি লাখ কোটি আটশত আটাশি দশমিক আট আট') self.assertEqual(n.to_ordinal(900000000000000.9), u'নয় কোটি কোটি দশমিক নয়') self.assertEqual(n.to_ordinal(999999999999999.9), u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়') # noqa: E501 self.assertEqual(n.to_ordinal(9999999999999999.99), u'একশত কোটি কোটি') self.assertEqual(n.to_ordinal(99999999999999999.99), u'এক হাজার কোটি কোটি') self.assertEqual(n.to_ordinal('999999999999999999.99'), u'নয় হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয় নয়') # noqa: E501 def test_to_year(self): n = Num2Word_BN() self.assertEqual(n.to_year(1), u'এক সাল') self.assertEqual(n.to_year(1000), u'এক হাজার সাল') self.assertEqual(n.to_year(1500), u'এক হাজার পাঁচশত সাল') self.assertEqual(n.to_year(1820), u'এক হাজার আটশত বিশ সাল') self.assertEqual(n.to_year(1920), u'এক হাজার নয়শত বিশ সাল') self.assertEqual(n.to_year(2024), u'দুই হাজার চব্বিশ সাল') self.assertEqual(n.to_year(2004), u'দুই হাজার চার সাল') def test_to_ordinal_num(self): n = Num2Word_BN() self.assertEqual(n.to_ordinal_num(1), u'প্রথম') self.assertEqual(n.to_ordinal_num(1000), u'এক হাজারতম') self.assertEqual(n.to_ordinal_num(1500), u'এক হাজার পাঁচশতম') self.assertEqual(n.to_ordinal_num(1820), u'এক হাজার আটশত বিশতম') self.assertEqual(n.to_ordinal_num(1920), u'এক হাজার নয়শত বিশতম') self.assertEqual(n.to_ordinal_num(2024), u'দুই হাজার চব্বিশতম') self.assertEqual(n.to_ordinal_num(2004), u'দুই হাজার চারতম') def test_max_number_error(self): n = Num2Word_BN() with self.assertRaises(NumberTooLargeError): n.to_ordinal( 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991) # noqa: E501 with self.assertRaises(NumberTooLargeError): n.to_cardinal( 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991) # noqa: E501 with self.assertRaises(NumberTooLargeError): n.to_year( 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991) # noqa: E501 with self.assertRaises(NumberTooLargeError): n.to_ordinal_num( 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991) # noqa: E501 with self.assertRaises(NumberTooLargeError): n.to_currency( 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991) # noqa: E501 with self.assertRaises(NumberTooLargeError): num2words( 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991, # noqa: E501 lang="bn") def test_is_smaller_than_max_number(self): n = Num2Word_BN() self.assertEqual(n._is_smaller_than_max_number(55555), True) def test_is_smaller_than_max_number_error(self): with self.assertRaises(NumberTooLargeError): n = Num2Word_BN() n._is_smaller_than_max_number(99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999) # noqa: E501 def test_parse_number(self): n = Num2Word_BN() self.assertEqual(n.parse_number(Decimal(3.25)), (3, 25)) self.assertEqual(n.parse_number(Decimal(300.2550)), (300, 2549999999999954525264911353588104248046875)) def test_parse_paisa(self): n = Num2Word_BN() self.assertEqual(n.parse_paisa(Decimal(3.25)), (3, 25)) self.assertEqual(n.parse_paisa(300.2550), (300, 25)) self.assertEqual(n.parse_paisa(100.5), (100, 50)) def test_number_to_bengali_word(self): n = Num2Word_BN() self.assertEqual(n._number_to_bengali_word(3), "তিন") self.assertEqual(n._number_to_bengali_word(2550), "দুই হাজার পাঁচশত পঞ্চাশ") self.assertEqual(n._number_to_bengali_word(9999999999999999), "নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই") # noqa: E501 num2words-0.5.14/tests/test_ca.py000066400000000000000000000136101473005321200166750ustar00rootroot00000000000000from __future__ import unicode_literals from unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (1, "un"), (2, "dos"), (3, "tres"), (5.5, "cinc punt cinc"), (11, "onze"), (12, "dotze"), (16, "setze"), (17.42, "disset punt quatre dos"), (19, "dinou"), (20, "vint"), (21, "vint-i-un"), (26, "vint-i-sis"), (27.312, "vint-i-set punt tres un dos"), (28, "vint-i-vuit"), (30, "trenta"), (31, "trenta-un"), (40, "quaranta"), (44, "quaranta-quatre"), (50, "cinquanta"), (53.486, "cinquanta-tres punt quatre vuit sis"), (55, "cinquanta-cinc"), (60, "seixanta"), (67, "seixanta-set"), (70, "setanta"), (79, "setanta-nou"), (89, "vuitanta-nou"), (95, "noranta-cinc"), (100, "cent"), (101, "cent un"), (199, "cent noranta-nou"), (203, "dos-cents tres"), (287, "dos-cents vuitanta-set"), (300.42, "tres-cents punt quatre dos"), (356, "tres-cents cinquanta-sis"), (400, "quatre-cents"), (434, "quatre-cents trenta-quatre"), (555, "cinc-cents cinquanta-cinc"), (578, "cinc-cents setanta-vuit"), (666, "sis-cents seixanta-sis"), (689, "sis-cents vuitanta-nou"), (729, "set-cents vint-i-nou"), (777, "set-cents setanta-set"), (888, "vuit-cents vuitanta-vuit"), (894, "vuit-cents noranta-quatre"), (999, "nou-cents noranta-nou"), (1000, "mil"), (1001, "mil un"), (1097, "mil noranta-set"), (1104, "mil cent quatre"), (1243, "mil dos-cents quaranta-tres"), (2385, "dos mil tres-cents vuitanta-cinc"), (3766, "tres mil set-cents seixanta-sis"), (4196, "quatre mil cent noranta-sis"), (4196.42, "quatre mil cent noranta-sis punt quatre dos"), (5846, "cinc mil vuit-cents quaranta-sis"), (6459, "sis mil quatre-cents cinquanta-nou"), (7232, "set mil dos-cents trenta-dos"), (8569, "vuit mil cinc-cents seixanta-nou"), (9539, "nou mil cinc-cents trenta-nou"), (1000000, "un milió"), (1000001, "un milió un"), (4000000, "quatre milions"), (10000000000000, "deu bilions"), (100000000000000, "cent bilions"), (1000000000000000000, "un trilió"), (1000000000000000000000, "mil trilions"), (10000000000000000000000000, "deu quadrilions"), ) TEST_CASES_ORDINAL = ( (1, "primer"), (2, "segon"), (8, "vuitè"), (12, "dotzè"), (14, "catorzè"), (28, "vint-i-vuitè"), (33, "trenta-tresè"), (88, "vuitanta-vuitè"), (100, "centè"), (128, "cent vint-i-vuitè"), (199, "cent noranta-novè"), (1000, "milè"), (1827, "mil vuit-cents vint-i-setè"), (12345, "dotze mil tres-cents quaranta-cinquè"), (1000000, "milionè"), (1000000000000000, "mil bilionè"), (1000000000000000, "mil bilionè"), (1000000000000000000, "un trilionè"), # over 1e18 is not supported ) TEST_CASES_ORDINAL_NUM = ( (1, "1r"), (8, "8è"), (12, "12è"), (14, "14è"), (28, "28è"), (100, "100è"), (1000, "1000è"), (1000000, "1000000è"), ) TEST_CASES_TO_CURRENCY = ( (1.00, "un euro amb zero cèntims"), (1.01, "un euro amb un cèntim"), (2.00, "dos euros amb zero cèntims"), (8.00, "vuit euros amb zero cèntims"), (12.00, "dotze euros amb zero cèntims"), (21.00, "vint-i-un euros amb zero cèntims"), (81.25, "vuitanta-un euros amb vint-i-cinc cèntims"), (350.90, "tres-cents cinquanta euros amb noranta cèntims"), (100.00, "cent euros amb zero cèntims"), ) TEST_CASES_TO_CURRENCY_ESP = ( (1.00, "una pesseta amb zero cèntims"), (1.01, "una pesseta amb un cèntim"), (2.00, "dues pessetes amb zero cèntims"), (8.00, "vuit pessetes amb zero cèntims"), (12.00, "dotze pessetes amb zero cèntims"), (21.00, "vint-i-una pessetes amb zero cèntims"), (81.25, "vuitanta-una pessetes amb vint-i-cinc cèntims"), (350.90, "tres-centes cinquanta pessetes amb noranta cèntims"), (100.00, "cent pessetes amb zero cèntims"), ) TEST_CASES_TO_CURRENCY_USD = ( (1.00, "un dòlar amb zero centaus"), (2.00, "dos dòlars amb zero centaus"), (8.00, "vuit dòlars amb zero centaus"), (12.00, "dotze dòlars amb zero centaus"), (21.00, "vint-i-un dòlars amb zero centaus"), (81.25, "vuitanta-un dòlars amb vint-i-cinc centaus"), (350.90, "tres-cents cinquanta dòlars amb noranta centaus"), (100.00, "cent dòlars amb zero centaus"), ) TEST_CASES_TO_CURRENCY_GBP = ( (1.00, "una lliura amb zero penics"), (1.01, "una lliura amb un penic"), (2.00, "dues lliures amb zero penics"), (8.00, "vuit lliures amb zero penics"), (12.00, "dotze lliures amb zero penics"), (21.00, "vint-i-una lliures amb zero penics"), (81.25, "vuitanta-una lliures amb vint-i-cinc penics"), (350.90, "tres-centes cinquanta lliures amb noranta penics"), (100.00, "cent lliures amb zero penics"), ) class TestNum2WordsCA(TestCase): def _test_cases(self, cases, lang="ca", to="cardinal", **kwargs): for case in cases: self.assertEqual(num2words(case[0], lang=lang, to=to, **kwargs), case[1]) def test_cardinal(self): self._test_cases(TEST_CASES_CARDINAL) def test_ordinal(self): self._test_cases(TEST_CASES_ORDINAL, to="ordinal") def test_ordinal_num(self): self._test_cases(TEST_CASES_ORDINAL_NUM, to="ordinal_num") def test_currency(self): self._test_cases(TEST_CASES_TO_CURRENCY, to="currency", currency="EUR") def test_currency_esp(self): self._test_cases(TEST_CASES_TO_CURRENCY_ESP, to="currency", currency="ESP") def test_currency_usd(self): self._test_cases(TEST_CASES_TO_CURRENCY_USD, to="currency", currency="USD") def test_currency_gbp(self): self._test_cases(TEST_CASES_TO_CURRENCY_GBP, to="currency", currency="GBP") num2words-0.5.14/tests/test_ce.py000066400000000000000000000514031473005321200167030ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2023, Johannes Heinecke. All Rights Reserved. # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301 USA from __future__ import unicode_literals from unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = [ (1, "obl", "б", "цхьана"), (2, "comp", "в", "шиннал"), (3, "mat", "д", "кхааннах"), (4, "mat", "в", "веаннах"), (5, "abs", "й", "пхиъ"), (6, "dat", "д", "ялханна"), (7, "erg", "в", "ворхӀамма"), (8, "comp", "й", "бархӀаннал"), (9, "dat", "й", "иссанна"), (10, "erg", "б", "иттамма"), (11, "dat", "б", "цхьайттанна"), (12, "instr", "й", "шийттанца"), (13, "erg", "б", "кхойттамма"), (14, "all", "в", "вейттанга"), (15, "dat", "б", "пхийттанна"), (16, "dat", "й", "ялхиттанна"), (17, "dat", "в", "вуьрхӀиттанна"), (18, "attr", "й", "берхӀитта"), (19, "all", "й", "ткъайеснанга"), (20, "attr", "б", "ткъе"), (21, "all", "в", "ткъе цхаьнга"), (22, "obl", "в", "ткъе шина"), (23, "attr", "б", "ткъе кхо"), (24, "dat", "й", "ткъе йеанна"), (25, "attr", "й", "ткъе пхи"), (26, "abs", "б", "ткъе ялх"), (27, "abs", "в", "ткъе ворхӀ"), (28, "all", "б", "ткъе бархӀанга"), (29, "mat", "д", "ткъе иссаннах"), (30, "gen", "й", "ткъе иттаннан"), (31, "dat", "в", "ткъе цхьайттанна"), (32, "comp", "й", "ткъе шийттаннал"), (33, "instr", "в", "ткъе кхойттанца"), (34, "instr", "в", "ткъе вейттанца"), (35, "comp", "в", "ткъе пхийттаннал"), (36, "dat", "й", "ткъе ялхиттанна"), (37, "obl", "в", "ткъе вуьрхӀиттан"), (38, "dat", "й", "ткъе берхӀиттанна"), (39, "mat", "й", "ткъе ткъайеснаннах"), (40, "all", "д", "шовзткъанга"), (41, "obl", "в", "шовзткъе цхьана"), (42, "dat", "в", "шовзткъе шинна"), (43, "erg", "й", "шовзткъе кхаамма"), (44, "erg", "й", "шовзткъе йеамма"), (45, "comp", "д", "шовзткъе пхеаннал"), (46, "mat", "б", "шовзткъе ялханнах"), (47, "erg", "б", "шовзткъе ворхӀамма"), (48, "erg", "в", "шовзткъе бархӀамма"), (49, "all", "б", "шовзткъе иссанга"), (50, "mat", "й", "шовзткъе иттаннах"), (51, "comp", "в", "шовзткъе цхьайттаннал"), (52, "erg", "в", "шовзткъе шийттамма"), (53, "attr", "д", "шовзткъе кхойтта"), (54, "gen", "б", "шовзткъе бейттаннан"), (55, "attr", "д", "шовзткъе пхийтта"), (56, "instr", "й", "шовзткъе ялхиттанца"), (57, "obl", "б", "шовзткъе вуьрхӀиттан"), (58, "attr", "б", "шовзткъе берхӀитта"), (59, "all", "й", "шовзткъе ткъайеснанга"), (60, "all", "й", "кхузткъанга"), (61, "gen", "й", "кхузткъе цхьаннан"), (62, "all", "б", "кхузткъе шинга"), (63, "instr", "б", "кхузткъе кхаанца"), (64, "dat", "й", "кхузткъе йеанна"), (65, "instr", "й", "кхузткъе нхеанца"), (66, "all", "б", "кхузткъе ялханга"), (67, "erg", "д", "кхузткъе ворхӀамма"), (68, "instr", "д", "кхузткъе бархӀанца"), (69, "mat", "й", "кхузткъе иссаннах"), (70, "attr", "б", "кхузткъе итт"), (71, "gen", "б", "кхузткъе цхьайттаннан"), (72, "abs", "й", "кхузткъе шийтта"), (73, "mat", "д", "кхузткъе кхойттаннах"), (74, "instr", "й", "кхузткъе йейттанца"), (75, "mat", "в", "кхузткъе пхийттаннах"), (76, "instr", "б", "кхузткъе ялхиттанца"), (77, "dat", "в", "кхузткъе вуьрхӀиттанна"), (78, "erg", "д", "кхузткъе берхӀиттамма"), (79, "gen", "б", "кхузткъе ткъайеснаннан"), (80, "dat", "б", "дезткъанна"), (81, "gen", "б", "дезткъе цхьаннан"), (82, "dat", "б", "дезткъе шинна"), (83, "obl", "д", "дезткъе кхона"), (84, "erg", "в", "дезткъе веамма"), (85, "all", "в", "дезткъе пхеанга"), (86, "erg", "д", "дезткъе ялхамма"), (87, "comp", "б", "дезткъе ворхӀаннал"), (88, "dat", "д", "дезткъе бархӀанна"), (89, "erg", "б", "дезткъе иссамма"), (90, "obl", "й", "дезткъе иттан"), (91, "obl", "б", "дезткъе цхьайттан"), (92, "abs", "б", "дезткъе шийтта"), (93, "gen", "в", "дезткъе кхойттаннан"), (94, "comp", "б", "дезткъе бейттаннал"), (95, "all", "б", "дезткъе пхийттанга"), (96, "instr", "д", "дезткъе ялхиттанца"), (97, "erg", "д", "дезткъе вуьрхӀиттамма"), (98, "instr", "й", "дезткъе берхӀиттанца"), (99, "instr", "б", "дезткъе ткъайеснанца"), (0, "gen", "б", "нолан"), (100, "mat", "б", "бӀеннах"), (200, "attr", "д", "ши бӀе"), (300, "obl", "в", "кхо бӀен"), (400, "abs", "в", "ви бӀе"), (500, "all", "й", "пхи бӀенга"), (600, "abs", "й", "ялх бӀе"), (700, "mat", "й", "ворхӀ бӀеннах"), (800, "gen", "б", "бархӀ бӀеннан"), (900, "mat", "в", "исс бӀеннах"), (1000, "gen", "д", "эзарнан"), (1100, "instr", "д", "эзар бӀенца"), (1200, "instr", "д", "эзар ши бӀенца"), (1300, "comp", "б", "эзар кхо бӀеннал"), (1400, "instr", "д", "эзар ди бӀенца"), (1500, "comp", "б", "эзар пхи бӀеннал"), (1600, "erg", "б", "эзар ялх бӀемма"), (1700, "attr", "д", "эзар ворхӀ бӀе"), (1800, "obl", "д", "эзар бархӀ бӀен"), (1900, "gen", "й", "эзар исс бӀеннан"), (2000, "comp", "д", "ши эзарнал"), (2022, "comp", "д", "ши эзар ткъе шиннал"), (2100, "obl", "в", "ши эзар бӀен"), (423000, "erg", "в", "ви бӀе ткъе кхо эзарно"), ] TEST_CASES_ORDINAL = [ (1, "all", "б", "цхьалгӀа"), (2, "dat", "в", "шолгӀа"), (3, "obl", "й", "кхоалгӀа"), (4, "dat", "б", "боьалгӀа"), (5, "dat", "в", "пхоьалгӀа"), (6, "abs", "в", "йолхалгӀа"), (7, "abs", "в", "ворхӀалгӀа"), (8, "abs", "д", "борхӀалӀа"), (9, "comp", "д", "уьссалгӀа"), (10, "erg", "д", "уьтталгӀа"), (11, "all", "б", "цхьайтталгӀа"), (12, "abs", "й", "шийтталга"), (13, "gen", "в", "кхойтталгӀа"), (14, "gen", "в", "вейтталгӀа"), (15, "mat", "й", "пхийтталгӀа"), (16, "dat", "й", "ялхитталгӀа"), (17, "erg", "д", "вуьрхӀитталгӀа"), (18, "erg", "й", "берхитталӀа"), (19, "obl", "в", "ткъаесналгӀа"), (20, "abs", "в", "ткъолгӀа"), (21, "mat", "б", "ткъе цхьалгӀа"), (22, "erg", "б", "ткъе шолгӀа"), (23, "mat", "й", "ткъе кхоалгӀа"), (24, "obl", "б", "ткъе боьалгӀа"), (25, "abs", "д", "ткъе пхоьалгӀа"), (26, "all", "й", "ткъе йолхалгӀа"), (27, "mat", "в", "ткъе ворхӀалгӀа"), (28, "instr", "д", "ткъе борхӀалӀа"), (29, "obl", "б", "ткъе уьссалгӀа"), (30, "dat", "б", "ткъе уьтталгӀа"), (31, "obl", "й", "ткъе цхьайтталгӀа"), (32, "comp", "д", "ткъе шийтталга"), (33, "attr", "д", "ткъе кхойтталгӀа"), (34, "gen", "в", "ткъе вейтталгӀа"), (35, "erg", "д", "ткъе пхийтталгӀа"), (36, "all", "в", "ткъе ялхитталгӀа"), (37, "attr", "й", "ткъе вуьрхӀитталгӀа"), (38, "erg", "б", "ткъе берхитталӀа"), (39, "gen", "д", "ткъе ткъаесналгӀа"), (40, "abs", "й", "шовзткъалгІа"), (41, "erg", "й", "шовзткъе цхьалгӀа"), (42, "comp", "й", "шовзткъе шолгӀа"), (43, "obl", "д", "шовзткъе кхоалгӀа"), (44, "all", "й", "шовзткъе йоьалгӀа"), (45, "abs", "д", "шовзткъе пхоьалгӀа"), (46, "comp", "д", "шовзткъе йолхалгӀа"), (47, "comp", "й", "шовзткъе ворхӀалгӀа"), (48, "attr", "б", "шовзткъе борхӀалӀа"), (49, "comp", "й", "шовзткъе уьссалгӀа"), (50, "abs", "д", "шовзткъе уьтталгӀа"), (51, "dat", "б", "шовзткъе цхьайтталгӀа"), (52, "comp", "в", "шовзткъе шийтталга"), (53, "mat", "б", "шовзткъе кхойтталгӀа"), (54, "all", "д", "шовзткъе дейтталгӀа"), (55, "dat", "в", "шовзткъе пхийтталгӀа"), (56, "erg", "б", "шовзткъе ялхитталгӀа"), (57, "comp", "й", "шовзткъе вуьрхӀитталгӀа"), (58, "instr", "в", "шовзткъе берхитталӀа"), (59, "mat", "б", "шовзткъе ткъаесналгӀа"), (60, "all", "в", "кхузткъалгІа"), (61, "obl", "д", "кхузткъе цхьалгӀа"), (62, "instr", "д", "кхузткъе шолгӀа"), (63, "erg", "й", "кхузткъе кхоалгӀа"), (64, "dat", "д", "кхузткъе доьалгӀа"), (65, "gen", "д", "кхузткъе пхоьалгӀа"), (66, "mat", "в", "кхузткъе йолхалгӀа"), (67, "gen", "в", "кхузткъе ворхӀалгӀа"), (68, "attr", "б", "кхузткъе борхӀалӀа"), (69, "all", "д", "кхузткъе уьссалгӀа"), (70, "mat", "в", "кхузткъе уьтталгӀа"), (71, "gen", "й", "кхузткъе цхьайтталгӀа"), (72, "obl", "й", "кхузткъе шийтталга"), (73, "attr", "в", "кхузткъе кхойтталгӀа"), (74, "dat", "б", "кхузткъе бейтталгӀа"), (75, "instr", "в", "кхузткъе пхийтталгӀа"), (76, "gen", "в", "кхузткъе ялхитталгӀа"), (77, "erg", "д", "кхузткъе вуьрхӀитталгӀа"), (78, "all", "й", "кхузткъе берхитталӀа"), (79, "instr", "д", "кхузткъе ткъаесналгӀа"), (80, "dat", "в", "дезткъалгІа"), (81, "mat", "в", "дезткъе цхьалгӀа"), (82, "abs", "д", "дезткъе шолгӀа"), (83, "abs", "д", "дезткъе кхоалгӀа"), (84, "erg", "в", "дезткъе воьалгӀа"), (85, "obl", "й", "дезткъе пхоьалгӀа"), (86, "instr", "д", "дезткъе йолхалгӀа"), (87, "all", "в", "дезткъе ворхӀалгӀа"), (88, "dat", "д", "дезткъе борхӀалӀа"), (89, "obl", "б", "дезткъе уьссалгӀа"), (90, "instr", "в", "дезткъе уьтталгӀа"), (91, "abs", "й", "дезткъе цхьайтталгӀа"), (92, "comp", "в", "дезткъе шийтталга"), (93, "erg", "д", "дезткъе кхойтталгӀа"), (94, "obl", "й", "дезткъе йейтталгӀа"), (95, "comp", "б", "дезткъе пхийтталгӀа"), (96, "obl", "б", "дезткъе ялхитталгӀа"), (97, "gen", "й", "дезткъе вуьрхӀитталгӀа"), (98, "dat", "б", "дезткъе берхитталӀа"), (99, "abs", "д", "дезткъе ткъаесналгӀа"), (100, "abs", "в", "бІолгІа"), (200, "obl", "й", "ши бІолгІа"), (300, "mat", "в", "кхо бІолгІа"), (400, "gen", "б", "би бІолгІа"), (500, "erg", "й", "пхи бІолгІа"), (600, "gen", "д", "ялх бІолгІа"), (700, "instr", "й", "ворхӀ бІолгІа"), (800, "all", "б", "бархӀ бІолгІа"), (900, "comp", "б", "исс бІолгІа"), (1000, "dat", "д", "эзарлагІа"), (107, "gen", "в", "бӀе ворхӀалгӀа"), (214, "attr", "д", "ши бӀе дейтталгӀа"), (321, "comp", "д", "кхо бӀе ткъе цхьалгӀа"), (428, "dat", "в", "ви бӀе ткъе борхӀалӀа"), (535, "erg", "й", "пхи бӀе ткъе пхийтталгӀа"), (642, "all", "й", "ялх бӀе шовзткъе шолгӀа"), (749, "mat", "в", "ворхӀ бӀе шовзткъе уьссалгӀа"), (856, "attr", "й", "бархӀ бӀе шовзткъе ялхитталгӀа"), (963, "mat", "б", "исс бӀе кхузткъе кхоалгӀа"), (1070, "comp", "в", "эзар кхузткъе уьтталгӀа"), (1177, "dat", "в", "эзар бӀе кхузткъе вуьрхӀитталгӀа"), (1284, "abs", "д", "эзар ши бӀе дезткъе доьалгӀа"), (1391, "dat", "в", "эзар кхо бӀе дезткъе цхьайтталгӀа"), (1498, "abs", "в", "эзар ви бӀе дезткъе берхитталӀа"), (1605, "obl", "б", "эзар ялх бӀе пхоьалгӀа"), (1712, "erg", "й", "эзар ворхӀ бӀе шийтталга"), (1819, "all", "б", "эзар бархӀ бӀе ткъаесналгӀа"), (1926, "abs", "б", "эзар исс бӀе ткъе йолхалгӀа"), (2033, "all", "д", "ши эзар ткъе кхойтталгӀа"), (2140, "dat", "б", "ши эзар бӀе шовзткъалгІа"), (423000, "dat", "д", "ди бӀе ткъе кхо эзарлагІа"), ] TEST_CASES_YEAR = [ (1719, "abs", "эзар ворхӀ бӀе ткъайесна"), (1812, "abs", "эзар бархӀ бӀе шийтта"), (1926, "abs", "эзар исс бӀе ткъе ялх"), ] TEST_CASES_DECIMALS = [(123.4567, "бӀе ткъе кхоъ а диъ пхиъ ялх ворхӀ")] TEST_CASES_MILLIONS = [ (200020, "ши бӀе эзар ткъа"), (4000400, "ди миллион ди бӀе"), (60006000, "кхузткъе миллион ялх эзар"), (800080000, "бархӀ бӀе миллион дезткъе эзар"), (10001000000, "итт миллиард цхьа миллион"), (120012000000, "бӀе ткъе миллиард шийтта миллион"), (1400140000000, "цхьа биллион ди бӀе миллиард бӀе шовзткъе миллион"), (16001600000000, "ялхитта биллион цхьа миллиард ялх бӀе миллион"), (180018000000000, "бӀе дезткъе биллион берхӀитта миллиард"), (2000200000000000, "ши биллиард ши бӀе миллиард"), (22002200000000000, "ткъе ши биллиард ши биллион ши бӀе миллиард"), (240024000000000000, "ши бӀе шовзткъе биллиард ткъе ди биллион"), ( 2600260000000000000, "ши триллион ялх бӀе биллиард ши бӀе кхузткъе биллион", ), ( 28002800000000000000, "ткъе бархӀ триллион ши биллиард бархӀ бӀе биллион", ), (300030000000000000000, "кхо бӀе триллион ткъе итт биллиард"), ( 3200320000000000000000, "кхо триллиард ши бӀе триллион кхо бӀе ткъе биллиард", ), ( 34003400000000000000000, "ткъе дейтта триллиард кхо триллион ди бӀе биллиард", ), ( 360036000000000000000000, "кхо бӀе кхузткъе триллиард ткъе ялхитта триллион", ), ( 3800380000000000000000000, "кхо квадриллион бархӀ бӀе триллиард кхо бӀе дезткъе триллион", ), (40004000000000000000000000, "шовзткъе квадриллион ди триллиард"), ( 420042000000000000000000000, "ди бӀе ткъе квадриллион шовзткъе ши триллиард", ), ( 4400440000000000000000000000, "ди квадриллиард ди бӀе квадриллион ди бӀе шовзткъе триллиард", ), ( 46004600000000000000000000000, "шовзткъе ялх квадриллиард ди квадриллион ялх бӀе триллиард", ), ( 480048000000000000000000000000, "ди бӀе дезткъе квадриллиард шовзткъе бархӀ квадриллион", ), (5000500000000000000000000000000, "пхи квинтиллион пхи бӀе квадриллион"), ( 52005200000000000000000000000000, "шовзткъе шийтта квинтиллион пхи квадриллиард ши бӀе квадриллион", ), ( 540054000000000000000000000000000, "пхи бӀе шовзткъе квинтиллион шовзткъе дейтта квадриллиард", ), ( 5600560000000000000000000000000000, "пхи квинтиллиард ялх бӀе квинтиллион пхи бӀе кхузткъе квадриллиард", ), (10**56, "NOT IMPLEMENTED") ] TEST_CURRENCY = [ (143.55, "abs", "RUB", "бӀе шовзткъе кхо Сом, шовзткъе пхийтта Кепек"), (243.15, "dat", "RUB", "ши бӀе шовзткъе кхона Сом, пхийттан Кепек"), ] class Num2WordsCETest(TestCase): def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual( num2words(test[0], lang="ce", case=test[1], clazz=test[2]), test[3], ) def test_millions(self): for test in TEST_CASES_MILLIONS: self.assertEqual(num2words(test[0], lang="ce"), test[1]) def test_ordinal_number(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang="ce", to="ordinal", clazz=test[2]), test[3], ) self.assertEqual(num2words(3, to="ordinal_num", lang='ce'), "3-й") self.assertEqual(num2words(5, to="ordinal_num", lang='ce'), "5-й") self.assertEqual(num2words(82, to="ordinal_num", lang='ce'), "82-й") def test_year(self): for test in TEST_CASES_YEAR: self.assertEqual( num2words(test[0], lang="ce", to="year", case=test[1]), test[2] ) def test_currency(self): for test in TEST_CURRENCY: self.assertEqual( num2words( test[0], lang="ce", to="currency", currency=test[2], case=test[1], ), test[3], ) def test_currency_missing(self): with self.assertRaises(NotImplementedError): num2words(2.45, to="currency", lang='cy', currency="DEM") def test_decimals(self): for test in TEST_CASES_DECIMALS: self.assertEqual(num2words(test[0], lang="ce"), test[1]) num2words-0.5.14/tests/test_cli.py000066400000000000000000000075141473005321200170670ustar00rootroot00000000000000#!/usr/bin/env 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 from __future__ import unicode_literals import os import unittest import delegator import num2words class CliCaller(object): def __init__(self): self.cmd = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "bin", "num2words")) self.cmd_list = ["python", self.cmd] def run_cmd(self, *args): cmd_list = self.cmd_list + [str(arg) for arg in args] cmd = " ".join(cmd_list) return delegator.run(cmd) class CliTestCase(unittest.TestCase): """Test the command line app""" def setUp(self): self.cli = CliCaller() def test_cli_help(self): """num2words without arguments should exit with status 1 and show docopt's default short usage message """ output = self.cli.run_cmd() self.assertEqual(output.return_code, 1) self.assertTrue(output.err.startswith('Usage:')) def test_cli_list_langs(self): """You should be able to list all available languages """ output = self.cli.run_cmd('--list-languages') self.assertEqual( sorted(list(num2words.CONVERTER_CLASSES.keys())), [out for out in output.out.strip().splitlines() if out] ) output = self.cli.run_cmd('-L') self.assertEqual( sorted(list(num2words.CONVERTER_CLASSES.keys())), [out for out in output.out.strip().splitlines() if out] ) def test_cli_list_converters(self): """You should be able to list all available converters """ output = self.cli.run_cmd('--list-converters') self.assertEqual( sorted(list(num2words.CONVERTES_TYPES)), [out for out in output.out.strip().splitlines() if out] ) output = self.cli.run_cmd('-C') self.assertEqual( sorted(list(num2words.CONVERTES_TYPES)), [out for out in output.out.strip().splitlines() if out] ) def test_cli_default_lang(self): """Default to english """ output = self.cli.run_cmd(150) self.assertEqual(output.return_code, 0) self.assertEqual( output.out.strip(), "one hundred and fifty" ) def test_cli_with_lang(self): """You should be able to specify a language """ output = self.cli.run_cmd(150, '--lang', 'es') self.assertEqual(output.return_code, 0) self.assertEqual( output.out.strip(), "ciento cincuenta" ) def test_cli_with_lang_to(self): """You should be able to specify a language and currency """ output = self.cli.run_cmd(150.55, '--lang', 'es', '--to', 'currency') self.assertEqual(output.return_code, 0) self.assertEqual( (output.out.decode('utf-8') if hasattr(output.out, 'decode') else output.out).strip(), "ciento cincuenta euros con cincuenta y cinco céntimos" ) num2words-0.5.14/tests/test_cs.py000066400000000000000000000117141473005321200167220ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsCSTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(100, lang='cs'), "sto") self.assertEqual(num2words(101, lang='cs'), "sto jedna") self.assertEqual(num2words(110, lang='cs'), "sto deset") self.assertEqual(num2words(115, lang='cs'), "sto patnáct") self.assertEqual(num2words(123, lang='cs'), "sto dvacet tři") self.assertEqual(num2words(1000, lang='cs'), "tisíc") self.assertEqual(num2words(1001, lang='cs'), "tisíc jedna") self.assertEqual(num2words(2012, lang='cs'), "dva tisíce dvanáct") self.assertEqual( num2words(10.02, lang='cs'), "deset celá nula dva" ) self.assertEqual( num2words(15.007, lang='cs'), "patnáct celá nula nula sedm" ) self.assertEqual( num2words(12519.85, lang='cs'), "dvanáct tisíc pětset devatenáct celá osmdesát pět" ) self.assertEqual( num2words(123.50, lang='cs'), "sto dvacet tři celá pět" ) self.assertEqual( num2words(1234567890, lang='cs'), "miliarda dvěstě třicet čtyři miliony pětset šedesát " "sedm tisíc osmset devadesát" ) self.assertEqual( num2words(215461407892039002157189883901676, lang='cs'), "dvěstě patnáct quintillionů čtyřista šedesát jedna kvadriliard " "čtyřista sedm kvadrilionů osmset devadesát dva triliardy třicet " "devět trilionů dva biliardy sto padesát sedm bilionů sto " "osmdesát devět miliard osmset osmdesát tři miliony " "devětset jedna tisíc šestset sedmdesát šest" ) self.assertEqual( num2words(719094234693663034822824384220291, lang='cs'), "sedmset devatenáct quintillionů devadesát " "čtyři kvadriliardy dvěstě třicet čtyři " "kvadriliony šestset devadesát tři triliardy " "šestset šedesát tři triliony třicet čtyři biliardy osmset " "dvacet dva biliony osmset dvacet čtyři " "miliardy třista osmdesát čtyři miliony dvěstě dvacet " "tisíc dvěstě devadesát jedna" ) def test_to_ordinal(self): # @TODO: implement to_ordinal with self.assertRaises(NotImplementedError): num2words(1, lang='cs', to='ordinal') def test_currency(self): self.assertEqual( num2words(10.0, lang='cs', to='currency', currency='EUR'), "deset euro, nula centů") self.assertEqual( num2words(1.0, lang='cs', to='currency', currency='CZK'), "jedna koruna, nula haléřů") self.assertEqual( num2words(1234.56, lang='cs', to='currency', currency='EUR'), "tisíc dvěstě třicet čtyři euro, padesát šest centů") self.assertEqual( num2words(1234.56, lang='cs', to='currency', currency='CZK'), "tisíc dvěstě třicet čtyři koruny, padesát šest haléřů") self.assertEqual( num2words(101.11, lang='cs', to='currency', currency='EUR', separator=' a'), "sto jedna euro a jedenáct centů") self.assertEqual( num2words(101.21, lang='cs', to='currency', currency='CZK', separator=' a'), "sto jedna korun a dvacet jedna haléřů" ) self.assertEqual( num2words(-12519.85, lang='cs', to='currency', cents=False), "mínus dvanáct tisíc pětset devatenáct euro, 85 centů" ) self.assertEqual( num2words(123.50, lang='cs', to='currency', currency='CZK', separator=' a'), "sto dvacet tři koruny a padesát haléřů" ) self.assertEqual( num2words(19.50, lang='cs', to='currency', cents=False), "devatenáct euro, 50 centů" ) num2words-0.5.14/tests/test_currency.py000066400000000000000000000060371473005321200201510ustar00rootroot00000000000000# -*- 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 decimal import Decimal from unittest import TestCase from num2words.currency import parse_currency_parts class CurrencyTestCase(TestCase): def test_parse_currency_parts(self): # integer with cents self.assertEqual(parse_currency_parts(101), (1, 1, False)) self.assertEqual(parse_currency_parts(-123), (1, 23, True)) # integer without cents self.assertEqual(parse_currency_parts(101, is_int_with_cents=False), (101, 0, False)) self.assertEqual(parse_currency_parts(-123, is_int_with_cents=False), (123, 0, True)) # float self.assertEqual(parse_currency_parts(1.01), (1, 1, False)) self.assertEqual(parse_currency_parts(-1.23), (1, 23, True)) self.assertEqual(parse_currency_parts(-1.2), (1, 20, True)) self.assertEqual(parse_currency_parts(0.004), (0, 0, False)) self.assertEqual(parse_currency_parts(0.005), (0, 1, False)) self.assertEqual(parse_currency_parts(0.006), (0, 1, False)) self.assertEqual(parse_currency_parts(0.0005), (0, 0, False)) self.assertEqual(parse_currency_parts(0.984), (0, 98, False)) self.assertEqual(parse_currency_parts(0.989), (0, 99, False)) self.assertEqual(parse_currency_parts(0.994), (0, 99, False)) self.assertEqual(parse_currency_parts(0.999), (1, 0, False)) # self.assertEqual(parse_currency_parts(0.985), (0, 99, False)) # self.assertEqual(parse_currency_parts(0.995), (1, 0, False)) # decimal self.assertEqual(parse_currency_parts(Decimal("1.01")), (1, 1, False)) self.assertEqual(parse_currency_parts(Decimal("-1.23")), (1, 23, True)) self.assertEqual(parse_currency_parts(Decimal("-1.233")), (1, 23, True)) self.assertEqual(parse_currency_parts(Decimal("-1.989")), (1, 99, True)) # string self.assertEqual(parse_currency_parts("1.01"), (1, 1, False)) self.assertEqual(parse_currency_parts("-1.23"), (1, 23, True)) self.assertEqual(parse_currency_parts("-1.2"), (1, 20, True)) self.assertEqual(parse_currency_parts("1"), (1, 0, False)) num2words-0.5.14/tests/test_cy.py000066400000000000000000000356361473005321200167410ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2023, Johannes Heinecke. All Rights Reserved. # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301 USA from __future__ import unicode_literals from unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (0, "dim"), (1, "un"), (1, "un"), (2, "dau"), (3, "tri"), (4, "pedwar"), (5, "pump"), (6, "chwech"), (7, "saith"), (8, "wyth"), (9, "naw"), (10, "deg"), (11, "un ar ddeg"), (12, "deuddeg"), (13, "tri ar ddeg"), (14, "pedwar ar ddeg"), (15, "pymtheg"), (16, "un ar bymtheg"), (17, "dau ar bymtheg"), (18, "deunaw"), (19, "pedwar ar bymtheg"), (20, "ugain"), (21, "un ar hugain"), (22, "dau ar hugain"), (23, "tri ar hugain"), (24, "pedwar ar hugain"), (25, "pump ar hugain"), (26, "chwech ar hugain"), (27, "saith ar hugain"), (28, "wyth ar hugain"), (29, "naw ar hugain"), (30, "deg ar hugain"), (31, "un ar ddeg ar hugain"), (32, "deuddeg ar hugain"), (33, "tri ar ddeg ar hugain"), (34, "pedwar ar ddeg ar hugain"), (35, "pymtheg ar hugain"), (36, "un ar bymtheg ar hugain"), (37, "dau ar bymtheg ar hugain"), (38, "deunaw ar hugain"), (39, "pedwar ar bymtheg ar hugain"), (40, "deugain"), (41, "un a deugain"), (42, "dau a deugain"), (43, "tri a deugain"), (44, "pedwar a deugain"), (45, "pump a deugain"), (46, "chwech a deugain"), (47, "saith a deugain"), (48, "wyth a deugain"), (49, "naw a deugain"), (50, "hanner cant"), (51, "hanner cant ac un"), (52, "hanner cant a dau"), (53, "hanner cant a thri"), (54, "hanner cant a phedwar"), (55, "hanner cant a phump"), (56, "hanner cant a chwech"), (57, "hanner cant a saith"), (58, "hanner cant a wyth"), (59, "hanner cant a naw"), (60, "trigain"), (61, "un a thrigain"), (62, "dau a thrigain"), (63, "tri a thrigain"), (64, "pedwar a thrigain"), (65, "pump a thrigain"), (66, "chwech a thrigain"), (67, "saith a thrigain"), (68, "wyth a thrigain"), (69, "naw a thrigain"), (70, "deg a thrigain"), (71, "un ar ddeg a thrigain"), (72, "deuddeg a thrigain"), (73, "tri ar ddeg a thrigain"), (74, "pedwar ar ddeg a thrigain"), (75, "pymtheg a thrigain"), (76, "un ar bymtheg a thrigain"), (77, "dau ar bymtheg a thrigain"), (78, "deunaw a thrigain"), (79, "pedwar ar bymtheg a thrigain"), (80, "pedwar ugain"), (81, "un a phedwar ugain"), (82, "dau a phedwar ugain"), (83, "tri a phedwar ugain"), (84, "pedwar a phedwar ugain"), (85, "pump a phedwar ugain"), (86, "chwech a phedwar ugain"), (87, "saith a phedwar ugain"), (88, "wyth a phedwar ugain"), (89, "naw a phedwar ugain"), (90, "deg a phedwar ugain"), (91, "un ar ddeg a phedwar ugain"), (92, "deuddeg a phedwar ugain"), (93, "tri ar ddeg a phedwar ugain"), (94, "pedwar ar ddeg a phedwar ugain"), (95, "pymtheg a phedwar ugain"), (96, "un ar bymtheg a phedwar ugain"), (97, "dau ar bymtheg a phedwar ugain"), (98, "deunaw a phedwar ugain"), (99, "pedwar ar bymtheg a phedwar ugain"), (100, "cant"), (101, "cant ac un"), (102, "cant a dau"), (103, "cant a thri"), (104, "cant a phedwar"), (105, "cant a phump"), (106, "cant a chwech"), (107, "cant a saith"), (108, "cant ac wyth"), (109, "cant a naw"), (110, "cant a deg"), (111, "cant ac un ar ddeg"), (112, "cant a deuddeg"), (113, "cant a thri ar ddeg"), (114, "cant a phedwar ar ddeg"), (115, "cant a phymtheg"), (116, "cant ac un ar bymtheg"), (117, "cant a dau ar bymtheg"), (118, "cant a deunaw"), (119, "cant a phedwar ar bymtheg"), (120, "cant ac ugain"), (121, "cant ac un ar hugain"), (122, "cant a dau ar hugain"), (100, "cant"), (217, "dau gant a dau ar bymtheg"), (334, "tri chant a phedwar ar ddeg ar hugain"), (451, "pedwar cant a hanner ac un"), (568, "pump cant ac wyth a thrigain"), (685, "chwech chant a phump a phedwar ugain"), (802, "wyth cant a dau"), (919, "naw cant a phedwar ar bymtheg"), (100, "cant"), (150, "cant a hanner"), (200, "dau gant"), (300, "tri chant"), (400, "pedwar cant"), (500, "pump cant"), (600, "chwech chant"), (700, "saith cant"), (800, "wyth cant"), (900, "naw cant"), (1000, "mil"), (1000, "mil"), (12111, "deuddeg mil cant ac un ar ddeg"), (23222, "tair ar hugain mil dau gant a dau ar hugain"), ( 34333, "pedair ar ddeg ar hugain mil tri chant a thri ar ddeg ar hugain", ), (45444, "pump a deugain mil pedwar cant a phedwar a deugain"), (56555, "hanner cant a chwech mil pump cant a hanner a phump"), (67666, "saith a thrigain mil chwech chant a chwech a thrigain"), (78777, "deunaw a thrigain mil saith cant a dau ar bymtheg a thrigain"), (89888, "naw a phedwar ugain mil wyth cant ac wyth a phedwar ugain"), (100999, "cant mil naw cant a phedwar ar bymtheg a phedwar ugain"), (112110, "cant a deuddeg mil cant a deg"), (123221, "cant a thair ar hugain mil dau gant ac un ar hugain"), ( 134332, "cant a phedair ar ddeg ar hugain mil tri chant a deuddeg ar hugain", ), (145443, "cant a phump a deugain mil pedwar cant a thri a deugain"), (156554, "cant a hanner a chwech mil pump cant a hanner a phedwar"), (123, "cant a thri ar hugain"), (2345, "dwy fil tri chant a phump a deugain"), (34567, "pedair ar ddeg ar hugain mil pump cant a saith a thrigain"), (654321, "chwech chant a hanner a phedair mil tri chant ac un ar hugain"), ( 7654321, "saith miliwn chwech chant a hanner a " "phedair mil tri chant ac un ar hugain", ), ( 987654321, "naw cant a saith a phedwar ugain miliwn chwech chant a " "hanner a phedair mil tri chant ac un ar hugain", ), ( 123456789012, "cant a thri ar hugain biliwn pedwar cant a hanner a chwech miliwn " "saith cant a naw a phedwar ugain mil deuddeg", ), (2023, "dwy fil tri ar hugain"), (-40123, "meinws deugain mil cant a thri ar hugain"), (12340000000000000, "deuddeg cwadriliwn tri chant a deugain triliwn"), (3000000000000000, "tri chwadriliwn"), (2500000000000000000000000000000000, "dau ddengiliwn pump cant noniliwn"), ) TEST_CASES_CARDINAL_FEM = ( (2, "dwy"), (3, "tair"), (4, "pedair"), (5, "pump"), (6, "chwech"), (7, "saith"), (8, "wyth"), (9, "naw"), (10, "deg"), (11, "un ar ddeg"), (12, "deuddeg"), (13, "tair ar ddeg"), (14, "pedair ar ddeg"), (15, "pymtheg"), (16, "un ar bymtheg"), (17, "dwy ar bymtheg"), (18, "deunaw"), (19, "pedair ar bymtheg"), (20, "ugain"), (21, "un ar hugain"), (22, "dwy ar hugain"), (23, "tair ar hugain"), (24, "pedair ar hugain"), (25, "pump ar hugain"), (26, "chwech ar hugain"), (27, "saith ar hugain"), (28, "wyth ar hugain"), (29, "naw ar hugain"), (30, "deg ar hugain"), (31, "un ar ddeg ar hugain"), (32, "deuddeg ar hugain"), (33, "tair ar ddeg ar hugain"), (34, "pedair ar ddeg ar hugain"), (35, "pymtheg ar hugain"), (36, "un ar bymtheg ar hugain"), (37, "dwy ar bymtheg ar hugain"), (38, "deunaw ar hugain"), (39, "pedair ar bymtheg ar hugain"), (40, "deugain"), (41, "un a deugain"), (42, "dwy a deugain"), (43, "tair a deugain"), (44, "pedair a deugain"), (45, "pump a deugain"), (46, "chwech a deugain"), (47, "saith a deugain"), (48, "wyth a deugain"), (49, "naw a deugain"), (50, "hanner cant"), (51, "hanner cant ac un"), (52, "hanner cant a dwy"), (53, "hanner cant a thair"), (54, "hanner cant a phedair"), (55, "hanner cant a phump"), (56, "hanner cant a chwech"), (57, "hanner cant a saith"), (58, "hanner cant a wyth"), (59, "hanner cant a naw"), (60, "trigain"), (61, "un a thrigain"), (62, "dwy a thrigain"), ) TEST_CASES_ORDINAL = ( (0, "dimfed"), (1, "cyntaf"), (2, "ail"), (3, "trydydd"), (4, "pedwerydd"), (5, "pumed"), (6, "chweched"), (7, "saithfed"), (8, "wythfed"), (9, "nawfed"), (10, "degfed"), (11, "unfed ar ddeg"), (12, "deuddegfed"), (13, "trydydd ar ddeg"), (14, "pedwerydd ar ddeg"), (15, "pymthegfed"), (16, "unfed ar bymtheg"), (17, "ail ar bymtheg"), (18, "deunawfed"), (19, "pedwerydd ar bymtheg"), (20, "ugainfed"), (21, "cyntaf ar hugain"), (22, "ail ar hugain"), (23, "trydydd ar hugain"), (24, "pedwerydd ar hugain"), (25, "pumed ar hugain"), (26, "chweched ar hugain"), (27, "saithfed ar hugain"), (28, "wythfed ar hugain"), (29, "nawfed ar hugain"), (30, "degfed ar hugain"), (31, "unfed ar ddeg ar hugain"), (32, "deuddegfed ar hugain"), (33, "trydydd ar ddeg ar hugain"), (34, "pedwerydd ar ddeg ar hugain"), (35, "pymthegfed ar hugain"), (36, "unfed ar bymtheg ar hugain"), (37, "ail ar bymtheg ar hugain"), (38, "deunawfed ar hugain"), (39, "pedwerydd ar bymtheg ar hugain"), (40, "deugainfed"), (41, "cyntaf a deugain"), (42, "ail a deugain"), (43, "trydydd a deugain"), (44, "pedwerydd a deugain"), (45, "pumed a deugain"), (46, "chweched a deugain"), (47, "saithfed a deugain"), (48, "wythfed a deugain"), (49, "nawfed a deugain"), (50, "degfed a deugain"), (51, "unfed ar ddeg a deugain"), (52, "deuddegfed a deugain"), (53, "trydydd ar ddeg a deugain"), (54, "pedwerydd ar ddeg a deugain"), (55, "pymthegfed a deugain"), (56, "unfed ar bymtheg a deugain"), (57, "ail ar bymtheg a deugain"), (58, "deunawfed a deugain"), (59, "pedwerydd ar bymtheg a deugain"), (60, "trigainfed"), (61, "cyntaf a thrigain"), (62, "ail a thrigain"), (63, "trydydd a thrigain"), (64, "pedwerydd a thrigain"), (65, "pumed a thrigain"), (66, "chweched a thrigain"), (67, "saithfed a thrigain"), (68, "wythfed a thrigain"), (69, "nawfed a thrigain"), (70, "degfed a thrigain"), (71, "unfed ar ddeg a thrigain"), (72, "deuddegfed a thrigain"), (73, "trydydd ar ddeg a thrigain"), (74, "pedwerydd ar ddeg a thrigain"), (75, "pymthegfed a thrigain"), (76, "unfed ar bymtheg a thrigain"), (77, "ail ar bymtheg a thrigain"), (78, "deunawfed a thrigain"), (79, "pedwerydd ar bymtheg a thrigain"), (80, "pedwar ugainfed"), (81, "cyntaf a phedwar ugain"), (82, "ail a phedwar ugain"), (83, "trydydd a phedwar ugain"), (84, "pedwerydd a phedwar ugain"), (85, "pumed a phedwar ugain"), (86, "chweched a phedwar ugain"), (87, "saithfed a phedwar ugain"), (88, "wythfed a phedwar ugain"), (89, "nawfed a phedwar ugain"), (90, "degfed a phedwar ugain"), (91, "unfed ar ddeg a phedwar ugain"), (92, "deuddegfed a phedwar ugain"), (93, "trydydd ar ddeg a phedwar ugain"), (94, "pedwerydd ar ddeg a phedwar ugain"), (95, "pymthegfed a phedwar ugain"), (96, "unfed ar bymtheg a phedwar ugain"), (97, "ail ar bymtheg a phedwar ugain"), (98, "deunawfed a phedwar ugain"), (99, "pedwerydd ar bymtheg a phedwar ugain"), (100, "canfed"), ) TEST_CASES_YEAR = [ (1922, "mil naw dau dau"), (1989, "mil naw wyth naw"), (1812, "mil wyth un dau"), (2012, "dwy fil deuddeg"), (2023, "dwy fil tri ar hugain") ] TEST_CASES_DECIMALS = [ (123.4567, "cant a thri ar hugain pwynt pedwar pump chwech saith") ] TEST_CASES_TO_CURRENCY_GBP = ( (0.00, "dim punt"), (0.23, "tri cheiniog ar hugain"), (2.04, "dwy bunt, pedwar ceiniog"), (3.50, "tair punt, hanner cant ceiniog"), (2002.15, "dwy fil dwy o bunnoedd, pymtheg ceiniog"), (100.01, "cant punt, ceiniog"), (50.00, "hanner cant punt"), (51.00, "hanner cant ac un punt"), (152.50, "cant a hanner a dwy o bunnoedd, hanner cant ceiniog"), ) TEST_CASES_COUNTED = [ (2, "ci", "masc", "dau gi"), (2, "ty", "masc", "dau dy"), (2, "llwy", "fem", "dwy lwy"), (2, "rhaglen", "masc", "dau raglen"), (11, "ci", "masc", "un ci ar ddeg"), (13, "ci", "masc", "tri chi ar ddeg"), (26, "ci", "masc", "chwech chi ar hugain"), (56, "ci", "masc", "hanner cant a chwech chi"), (100, "cwn", "masc", "cant o gwn"), (2000, "cathod", "fem", "dwy fil o gathod"), (11, "cath", "fem", "un cath ar ddeg"), (13, "cath", "fem", "tair cath ar ddeg"), (26, "cath", "fem", "chwech chath ar hugain"), (42, "cath", "fem", "dwy gath a deugain"), (56, "cath", "fem", "hanner cant a chwech chath"), ] class Num2WordsCYTest(TestCase): def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang="cy"), test[1]) def test_number_fem(self): for test in TEST_CASES_CARDINAL_FEM: self.assertEqual( num2words(test[0], lang="cy", gender="fem"), test[1] ) def test_number_not_implemented(self): with self.assertRaises(NotImplementedError): num2words(10**66, lang='cy') def test_decimals(self): for test in TEST_CASES_DECIMALS: self.assertEqual(num2words(test[0], lang="cy"), test[1]) def test_ordinals(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang="cy", to="ordinal"), test[1] ) def test_ordinal_not_implemented(self): with self.assertRaises(NotImplementedError): num2words(101, lang='cy', to="ordinal") def test_pounds(self): for test in TEST_CASES_TO_CURRENCY_GBP: self.assertEqual( num2words(test[0], lang="cy", to="currency", currency="GBP"), test[1], ) def test_other_cur(self): with self.assertRaises(NotImplementedError): num2words(10.23, lang="cy", to="currency", currency="DEM"), def test_counted(self): for test in TEST_CASES_COUNTED: self.assertEqual( num2words( test[0], lang="cy", counted=test[1], gender=test[2] ), test[3], ) # TODO 'ordinal_num', 'year' num2words-0.5.14/tests/test_da.py000066400000000000000000000040631473005321200167000ustar00rootroot00000000000000# 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 unittest import TestCase from num2words import num2words from num2words.lang_DA import Num2Word_DA class Num2WordsDKTest(TestCase): def test_ordinal(self): self.assertEqual(num2words(1, to="ordinal", lang="da"), "første") self.assertEqual(num2words(5, to="ordinal", lang="da"), "femte") def test_cardinal(self): self.assertEqual(num2words(0, to="cardinal", lang="da"), "nul") self.assertEqual(num2words(1, to="cardinal", lang="da"), "et") self.assertEqual(num2words(2, to="cardinal", lang="da"), "to") self.assertEqual(num2words(5, to="cardinal", lang="da"), "fem") self.assertEqual(num2words(8, to="cardinal", lang="da"), "otte") self.assertEqual(num2words(18, to="cardinal", lang="da"), "atten") self.assertEqual(num2words(45, to="cardinal", lang="da"), "femogfyrre") def test_to_ordinal_num(self): num2words_dk = Num2Word_DA() self.assertEqual(num2words_dk.to_ordinal_num(1), "1te") self.assertEqual(num2words_dk.to_ordinal_num(2), "2en") self.assertEqual(num2words_dk.to_ordinal_num(5), "5te") self.assertEqual(num2words_dk.to_ordinal_num(10), "10ende") num2words-0.5.14/tests/test_de.py000066400000000000000000000150211473005321200167000ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_TO_CURRENCY_EUR = ( (1.00, 'ein Euro und null Cent'), (2.01, 'zwei Euro und ein Cent'), (8.10, 'acht Euro und zehn Cent'), (12.26, 'zwölf Euro und sechsundzwanzig Cent'), (21.29, 'einundzwanzig Euro und neunundzwanzig Cent'), (81.25, 'einundachtzig Euro und fünfundzwanzig Cent'), (100.00, 'einhundert Euro und null Cent'), ) TEST_CASES_TO_CURRENCY_USD = ( (1.00, 'ein Dollar und null Cent'), (2.01, 'zwei Dollar und ein Cent'), (8.10, 'acht Dollar und zehn Cent'), (12.26, 'zwölf Dollar und sechsundzwanzig Cent'), (21.29, 'einundzwanzig Dollar und neunundzwanzig Cent'), (81.25, 'einundachtzig Dollar und fünfundzwanzig Cent'), (100.00, 'einhundert Dollar und null Cent'), ) TEST_CASES_TO_CURRENCY_GBP = ( (1.00, 'ein Pfund und null Pence'), (2.01, 'zwei Pfund und ein Penny'), (8.10, 'acht Pfund und zehn Pence'), (12.26, 'zwölf Pfund und sechsundzwanzig Pence'), (21.29, 'einundzwanzig Pfund und neunundzwanzig Pence'), (81.25, 'einundachtzig Pfund und fünfundzwanzig Pence'), (100.00, 'einhundert Pfund und null Pence'), ) TEST_CASES_TO_CURRENCY_DEM = ( (1.00, 'ein Mark und null Pfennig'), (2.01, 'zwei Mark und ein Pfennig'), (8.10, 'acht Mark und zehn Pfennig'), (12.26, 'zwölf Mark und sechsundzwanzig Pfennig'), (21.29, 'einundzwanzig Mark und neunundzwanzig Pfennig'), (81.25, 'einundachtzig Mark und fünfundzwanzig Pfennig'), (100.00, 'einhundert Mark und null Pfennig'), ) class Num2WordsDETest(TestCase): def test_ordinal_less_than_twenty(self): self.assertEqual(num2words(0, ordinal=True, lang='de'), "nullte") self.assertEqual(num2words(1, ordinal=True, lang='de'), "erste") self.assertEqual(num2words(7, ordinal=True, lang='de'), "siebte") self.assertEqual(num2words(8, ordinal=True, lang='de'), "achte") self.assertEqual(num2words(12, ordinal=True, lang='de'), "zwölfte") self.assertEqual(num2words(17, ordinal=True, lang='de'), "siebzehnte") def test_ordinal_more_than_twenty(self): self.assertEqual( num2words(81, ordinal=True, lang='de'), "einundachtzigste" ) def test_ordinal_at_crucial_number(self): self.assertEqual( num2words(100, ordinal=True, lang='de'), "hundertste" ) self.assertEqual( num2words(1000, ordinal=True, lang='de'), "tausendste" ) self.assertEqual( num2words(4000, ordinal=True, lang='de'), "viertausendste" ) self.assertEqual( num2words(1000000, ordinal=True, lang='de'), "millionste" ) self.assertEqual( num2words(2000000, ordinal=True, lang='de'), "zweimillionste" ) self.assertEqual( num2words(1000000000, ordinal=True, lang='de'), "milliardste" ) self.assertEqual( num2words(5000000000, ordinal=True, lang='de'), "fünfmilliardste" ) def test_cardinal_at_some_numbers(self): self.assertEqual(num2words(100, lang='de'), "einhundert") self.assertEqual(num2words(1000, lang='de'), "eintausend") self.assertEqual(num2words(5000, lang='de'), "fünftausend") self.assertEqual(num2words(10000, lang='de'), "zehntausend") self.assertEqual(num2words(1000000, lang='de'), "eine Million") self.assertEqual(num2words(2000000, lang='de'), "zwei Millionen") self.assertEqual(num2words(4000000000, lang='de'), "vier Milliarden") self.assertEqual(num2words(1000000000, lang='de'), "eine Milliarde") def test_cardinal_for_decimal_number(self): self.assertEqual( num2words(3.486, lang='de'), "drei Komma vier acht sechs" ) def test_giant_cardinal_for_merge(self): self.assertEqual( num2words(4500072900000111, lang='de'), "vier Billiarden fünfhundert Billionen " + "zweiundsiebzig Milliarden neunhundert Millionen einhundertelf" ) def test_ordinal_num(self): self.assertEqual(num2words(7, to="ordinal_num", lang='de'), "7.") self.assertEqual(num2words(81, to="ordinal_num", lang='de'), "81.") def test_ordinal_for_negative_numbers(self): self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='de') def test_ordinal_for_floating_numbers(self): self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='de') def test_currency_eur(self): for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang='de', to='currency', currency='EUR'), test[1] ) def test_currency_usd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='de', to='currency', currency='USD'), test[1] ) def test_currency_dem(self): for test in TEST_CASES_TO_CURRENCY_DEM: self.assertEqual( num2words(test[0], lang='de', to='currency', currency='DEM'), test[1] ) def test_currency_gbp(self): for test in TEST_CASES_TO_CURRENCY_GBP: self.assertEqual( num2words(test[0], lang='de', to='currency', currency='GBP'), test[1] ) def test_year(self): self.assertEqual(num2words(2002, to='year', lang='de'), 'zweitausendzwei') def test_year_before_2000(self): self.assertEqual(num2words(1780, to='year', lang='de'), 'siebzehnhundertachtzig') num2words-0.5.14/tests/test_en.py000066400000000000000000000171511473005321200167200ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsENTest(TestCase): def test_and_join_199(self): # ref https://github.com/savoirfairelinux/num2words/issues/8 self.assertEqual(num2words(199), "one hundred and ninety-nine") def test_ordinal(self): self.assertEqual( num2words(0, lang='en', to='ordinal'), 'zeroth' ) self.assertEqual( num2words(1, lang='en', to='ordinal'), 'first' ) self.assertEqual( num2words(13, lang='en', to='ordinal'), 'thirteenth' ) self.assertEqual( num2words(22, lang='en', to='ordinal'), 'twenty-second' ) self.assertEqual( num2words(12, lang='en', to='ordinal'), 'twelfth' ) self.assertEqual( num2words(130, lang='en', to='ordinal'), 'one hundred and thirtieth' ) self.assertEqual( num2words(1003, lang='en', to='ordinal'), 'one thousand and third' ) def test_ordinal_num(self): self.assertEqual(num2words(10, lang='en', to='ordinal_num'), '10th') self.assertEqual(num2words(21, lang='en', to='ordinal_num'), '21st') self.assertEqual(num2words(102, lang='en', to='ordinal_num'), '102nd') self.assertEqual(num2words(73, lang='en', to='ordinal_num'), '73rd') def test_cardinal_for_float_number(self): # issue 24 self.assertEqual(num2words(12.5), "twelve point five") self.assertEqual(num2words(12.51), "twelve point five one") self.assertEqual(num2words(12.53), "twelve point five three") self.assertEqual(num2words(12.59), "twelve point five nine") def test_overflow(self): with self.assertRaises(OverflowError): num2words("1000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000") def test_to_currency(self): self.assertEqual( num2words('38.4', lang='en', to='currency', separator=' and', cents=False, currency='USD'), "thirty-eight dollars and 40 cents" ) self.assertEqual( num2words('0', lang='en', to='currency', separator=' and', cents=False, currency='USD'), "zero dollars and 00 cents" ) self.assertEqual( num2words('1.01', lang='en', to='currency', separator=' and', cents=True, currency='USD'), "one dollar and one cent" ) self.assertEqual( num2words('4778.00', lang='en', to='currency', separator=' and', cents=True, currency='USD', adjective=True), 'four thousand, seven hundred and seventy-eight US dollars' ' and zero cents') self.assertEqual( num2words('4778.00', lang='en', to='currency', separator=' and', cents=True, currency='USD'), 'four thousand, seven hundred and seventy-eight dollars and' ' zero cents') self.assertEqual( num2words('1.1', lang='en', to='currency', separator=' and', cents=True, currency='MXN'), "one peso and ten cents" ) self.assertEqual( num2words('158.3', lang='en', to='currency', separator=' and', cents=True, currency='MXN'), "one hundred and fifty-eight pesos and thirty cents" ) self.assertEqual( num2words('2000.00', lang='en', to='currency', separator=' and', cents=True, currency='MXN'), "two thousand pesos and zero cents" ) self.assertEqual( num2words('4.01', lang='en', to='currency', separator=' and', cents=True, currency='MXN'), "four pesos and one cent" ) self.assertEqual( num2words('2000.00', lang='en', to='currency', separator=' and', cents=True, currency='UZS'), "two thousand sums and zero tiyins" ) def test_to_year(self): # issue 141 # "e2 e2" self.assertEqual(num2words(1990, lang='en', to='year'), 'nineteen ninety') self.assertEqual(num2words(5555, lang='en', to='year'), 'fifty-five fifty-five') self.assertEqual(num2words(2017, lang='en', to='year'), 'twenty seventeen') self.assertEqual(num2words(1066, lang='en', to='year'), 'ten sixty-six') self.assertEqual(num2words(1865, lang='en', to='year'), 'eighteen sixty-five') # "e3 and e1"; "e2 oh-e1"; "e3" self.assertEqual(num2words(3000, lang='en', to='year'), 'three thousand') self.assertEqual(num2words(2001, lang='en', to='year'), 'two thousand and one') self.assertEqual(num2words(1901, lang='en', to='year'), 'nineteen oh-one') self.assertEqual(num2words(2000, lang='en', to='year'), 'two thousand') self.assertEqual(num2words(905, lang='en', to='year'), 'nine oh-five') # "e2 hundred"; "e3" self.assertEqual(num2words(6600, lang='en', to='year'), 'sixty-six hundred') self.assertEqual(num2words(1900, lang='en', to='year'), 'nineteen hundred') self.assertEqual(num2words(600, lang='en', to='year'), 'six hundred') self.assertEqual(num2words(50, lang='en', to='year'), 'fifty') self.assertEqual(num2words(0, lang='en', to='year'), 'zero') # suffixes self.assertEqual(num2words(-44, lang='en', to='year'), 'forty-four BC') self.assertEqual(num2words(-44, lang='en', to='year', suffix='BCE'), 'forty-four BCE') self.assertEqual(num2words(1, lang='en', to='year', suffix='AD'), 'one AD') self.assertEqual(num2words(66, lang='en', to='year', suffix='m.y.a.'), 'sixty-six m.y.a.') self.assertEqual(num2words(-66000000, lang='en', to='year'), 'sixty-six million BC') num2words-0.5.14/tests/test_en_in.py000066400000000000000000000022641473005321200174050ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsENINTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(1e5, lang="en_IN"), "one lakh") self.assertEqual(num2words(1e6, lang="en_IN"), "ten lakh") self.assertEqual(num2words(1e7, lang="en_IN"), "one crore") num2words-0.5.14/tests/test_en_ng.py000066400000000000000000000077711473005321200174130ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsENNGTest(TestCase): # only the test for currency is writen as other # functions in the Class remains the # same and have been properly tested in the # test test_en which tests the parent class # upon which this class inherits def test_to_currency(self): language = 'en_NG' separator = ' and' self.assertEqual( num2words( '38.4', lang=language, to='currency', separator=separator, kobo=False ), "thirty-eight naira and 40 kobo" ) self.assertEqual( num2words( '0', lang=language, to='currency', separator=separator, kobo=False ), "zero naira and 00 kobo" ) self.assertEqual( num2words( '1.01', lang=language, to='currency', separator=separator, kobo=True ), "one naira and one kobo" ) self.assertEqual( num2words( '4778.00', lang=language, to='currency', separator=separator, kobo=True, adjective=True ), 'four thousand, seven hundred and seventy-eight Nigerian naira' ' and zero kobo') self.assertEqual( num2words( '4778.00', lang=language, to='currency', separator=separator, kobo=True ), 'four thousand, seven hundred and seventy-eight naira and' ' zero kobo') self.assertEqual( num2words( '1.1', lang=language, to='currency', separator=separator, kobo=True ), "one naira and ten kobo" ) self.assertEqual( num2words( '158.3', lang=language, to='currency', separator=separator, kobo=True ), "one hundred and fifty-eight naira and thirty kobo" ) self.assertEqual( num2words( '2000.00', lang=language, to='currency', separator=separator, kobo=True ), "two thousand naira and zero kobo" ) self.assertEqual( num2words( '4.01', lang=language, to='currency', separator=separator, kobo=True ), "four naira and one kobo" ) self.assertEqual( num2words( '2000.00', lang=language, to='currency', separator=separator, kobo=True ), "two thousand naira and zero kobo" ) num2words-0.5.14/tests/test_eo.py000066400000000000000000000135041473005321200167170ustar00rootroot00000000000000# -*- 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 unicode_literals from unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (1, "unu"), (2, "du"), (3, "tri"), (5.5, "kvin komo kvin"), (11, "dek unu"), (12, "dek du"), (16, "dek ses"), (17.42, "dek sep komo kvar du"), (19, "dek naŭ"), (20, "dudek"), (21, "dudek unu"), (26, "dudek ses"), (27.312, "dudek sep komo tri unu du"), (28, "dudek ok"), (30, "tridek"), (31, "tridek unu"), (40, "kvardek"), (44, "kvardek kvar"), (50, "kvindek"), (53.486, "kvindek tri komo kvar ok ses"), (55, "kvindek kvin"), (60, "sesdek"), (67, "sesdek sep"), (70, "sepdek"), (79, "sepdek naŭ"), (89, "okdek naŭ"), (95, "naŭdek kvin"), (100, "cent"), (101, "cent unu"), (199, "cent naŭdek naŭ"), (203, "ducent tri"), (287, "ducent okdek sep"), (300.42, "tricent komo kvar du"), (356, "tricent kvindek ses"), (400, "kvarcent"), (434, "kvarcent tridek kvar"), (578, "kvincent sepdek ok"), (689, "sescent okdek naŭ"), (729, "sepcent dudek naŭ"), (894, "okcent naŭdek kvar"), (999, "naŭcent naŭdek naŭ"), (1000, "mil"), (1001, "mil unu"), (1097, "mil naŭdek sep"), (1104, "mil cent kvar"), (1243, "mil ducent kvardek tri"), (2385, "du mil tricent okdek kvin"), (3766, "tri mil sepcent sesdek ses"), (4196, "kvar mil cent naŭdek ses"), (4196.42, "kvar mil cent naŭdek ses komo kvar du"), (5846, "kvin mil okcent kvardek ses"), (6459, "ses mil kvarcent kvindek naŭ"), (7232, "sep mil ducent tridek du"), (8569, "ok mil kvincent sesdek naŭ"), (9539, "naŭ mil kvincent tridek naŭ"), (1000000, "unu miliono"), (1000001, "unu miliono unu"), (4000000, "kvar milionoj"), (4000004, "kvar milionoj kvar"), (4300000, "kvar milionoj tricent mil"), (80000000, "okdek milionoj"), (300000000, "tricent milionoj"), (10000000000000, "dek bilionoj"), (10000000000010, "dek bilionoj dek"), (100000000000000, "cent bilionoj"), (1000000000000000000, "unu triliono"), (1000000000000000000000, "unu triliardo"), (10000000000000000000000000, "dek kvarilionoj") ) TEST_CASES_ORDINAL = ( (1, "unua"), (8, "oka"), (12, "dek dua"), (14, "dek kvara"), (28, "dudek oka"), (100, "centa"), (1000, "mila"), (1000000, "unu miliona"), (1000000000000000, "unu biliarda"), (1000000000000000000, "unu triliona") ) TEST_CASES_ORDINAL_NUM = ( (1, "1a"), (8, "8a"), (11, "11a"), (12, "12a"), (14, "14a"), (21, "21a"), (28, "28a"), (100, "100a"), (101, "101a"), (1000, "1000a"), (1000000, "1000000a") ) TEST_CASES_TO_CURRENCY_EUR = ( (1.00, "unu eŭro kaj nul centimo"), (2.01, "du eŭroj kaj unu centimo"), (8.10, "ok eŭroj kaj dek centimoj"), (12.26, "dek du eŭroj kaj dudek ses centimoj"), (21.29, "dudek unu eŭroj kaj dudek naŭ centimoj"), (81.25, "okdek unu eŭroj kaj dudek kvin centimoj"), (100.00, "cent eŭroj kaj nul centimo"), ) TEST_CASES_TO_CURRENCY_FRF = ( (1.00, "unu franko kaj nul centimo"), (2.01, "du frankoj kaj unu centimo"), (8.10, "ok frankoj kaj dek centimoj"), (12.27, "dek du frankoj kaj dudek sep centimoj"), (21.29, "dudek unu frankoj kaj dudek naŭ centimoj"), (81.25, "okdek unu frankoj kaj dudek kvin centimoj"), (100.00, "cent frankoj kaj nul centimo"), ) TEST_CASES_TO_CURRENCY_USD = ( (1.00, "unu dolaro kaj nul cendo"), (2.01, "du dolaroj kaj unu cendo"), (8.10, "ok dolaroj kaj dek cendoj"), (12.26, "dek du dolaroj kaj dudek ses cendoj"), (21.29, "dudek unu dolaroj kaj dudek naŭ cendoj"), (81.25, "okdek unu dolaroj kaj dudek kvin cendoj"), (100.00, "cent dolaroj kaj nul cendo"), ) class Num2WordsEOTest(TestCase): def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang="eo"), test[1]) def test_ordinal(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang="eo", ordinal=True), test[1] ) def test_ordinal_num(self): for test in TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang="eo", to="ordinal_num"), test[1] ) def test_currency_eur(self): for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang="eo", to="currency", currency="EUR"), test[1] ) def test_currency_frf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang="eo", to="currency", currency="FRF"), test[1] ) def test_currency_usd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang="eo", to="currency", currency="USD"), test[1] ) num2words-0.5.14/tests/test_errors.py000066400000000000000000000024411473005321200176260ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsErrorsTest(TestCase): def test_NotImplementedError(self): with self.assertRaises(NotImplementedError): num2words(100, lang="lalala") def test_types_NotImplementedError(self): with self.assertRaises(NotImplementedError): num2words(100, lang="en", to='babidibibidiboo!') num2words-0.5.14/tests/test_es.py000066400000000000000000003322141473005321200167250ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (1, 'uno'), (2, 'dos'), (3, 'tres'), (5.5, 'cinco punto cinco'), (11, 'once'), (12, 'doce'), (16, 'dieciséis'), (17.42, 'diecisiete punto cuatro dos'), (19, 'diecinueve'), (20, 'veinte'), (21, 'veintiuno'), (26, 'veintiséis'), (27.312, 'veintisiete punto tres uno dos'), (28, 'veintiocho'), (30, 'treinta'), (31, 'treinta y uno'), (40, 'cuarenta'), (44, 'cuarenta y cuatro'), (50, 'cincuenta'), (53.486, 'cincuenta y tres punto cuatro ocho seis'), (55, 'cincuenta y cinco'), (60, 'sesenta'), (67, 'sesenta y siete'), (70, 'setenta'), (79, 'setenta y nueve'), (89, 'ochenta y nueve'), (95, 'noventa y cinco'), (100, 'cien'), (101, 'ciento uno'), (199, 'ciento noventa y nueve'), (203, 'doscientos tres'), (287, 'doscientos ochenta y siete'), (300.42, 'trescientos punto cuatro dos'), (356, 'trescientos cincuenta y seis'), (400, 'cuatrocientos'), (434, 'cuatrocientos treinta y cuatro'), (578, 'quinientos setenta y ocho'), (689, 'seiscientos ochenta y nueve'), (729, 'setecientos veintinueve'), (894, 'ochocientos noventa y cuatro'), (999, 'novecientos noventa y nueve'), (1000, 'mil'), (1001, 'mil uno'), (1097, 'mil noventa y siete'), (1104, 'mil ciento cuatro'), (1243, 'mil doscientos cuarenta y tres'), (2385, 'dos mil trescientos ochenta y cinco'), (3766, 'tres mil setecientos sesenta y seis'), (4196, 'cuatro mil ciento noventa y seis'), (4196.42, 'cuatro mil ciento noventa y seis punto cuatro dos'), (5846, 'cinco mil ochocientos cuarenta y seis'), (6459, 'seis mil cuatrocientos cincuenta y nueve'), (7232, 'siete mil doscientos treinta y dos'), (8569, 'ocho mil quinientos sesenta y nueve'), (9539, 'nueve mil quinientos treinta y nueve'), (1000000, 'un millón'), (1000001, 'un millón uno'), (4000000, 'cuatro millones'), (10000000000000, 'diez billones'), (100000000000000, 'cien billones'), (1000000000000000000, 'un trillón'), (1000000000000000000000, 'mil trillones'), (10000000000000000000000000, 'diez cuatrillones') ) TEST_CASES_ORDINAL = ( (1, 'primero'), (8, 'octavo'), (12, 'décimosegundo'), (14, 'décimo cuarto'), (28, 'vigésimo octavo'), (100, 'centésimo'), (1000, 'milésimo'), (12345, 'docemilésimo tricentésimo quadragésimo quinto'), (1000000, 'millonésimo'), (1000000000000000, 'cuadrillonésimo'), (1000000000000000000, 'un trillón') # over 1e18 is not supported ) TEST_CASES_ORDINAL_NUM = ( (1, '1º'), (8, '8º'), (12, '12º'), (14, '14º'), (28, '28º'), (100, '100º'), (1000, '1000º'), (1000000, '1000000º') ) TEST_CASES_TO_CURRENCY = ( (1.00, 'un euro con cero céntimos'), (1.01, 'un euro con un céntimo'), (2.00, 'dos euros con cero céntimos'), (8.00, 'ocho euros con cero céntimos'), (12.00, 'doce euros con cero céntimos'), (21.00, 'veintiún euros con cero céntimos'), (81.25, 'ochenta y un euros con veinticinco céntimos'), (350.90, 'trescientos cincuenta euros con noventa céntimos'), (100.00, 'cien euros con cero céntimos'), ) TEST_CASES_TO_CURRENCY_ESP = ( (1.00, 'una peseta con cero céntimos'), (1.01, 'una peseta con un céntimo'), (2.00, 'dos pesetas con cero céntimos'), (8.00, 'ocho pesetas con cero céntimos'), (12.00, 'doce pesetas con cero céntimos'), (21.00, 'veintiuna pesetas con cero céntimos'), (81.25, 'ochenta y una pesetas con veinticinco céntimos'), (350.90, 'trescientas cincuenta pesetas con noventa céntimos'), (100.00, 'cien pesetas con cero céntimos'), ) TEST_CASES_TO_CURRENCY_USD = ( (1.00, 'un dólar con cero centavos'), (2.00, 'dos dólares con cero centavos'), (8.00, 'ocho dólares con cero centavos'), (12.00, 'doce dólares con cero centavos'), (21.00, 'veintiún dólares con cero centavos'), (81.25, 'ochenta y un dólares con veinticinco centavos'), (350.90, 'trescientos cincuenta dólares con noventa centavos'), (100.00, 'cien dólares con cero centavos'), ) TEST_CASES_TO_CURRENCY_PEN = ( (1.00, 'un sol con cero céntimos'), (2.00, 'dos soles con cero céntimos'), (8.00, 'ocho soles con cero céntimos'), (12.00, 'doce soles con cero céntimos'), (21.00, 'veintiún soles con cero céntimos'), (81.25, 'ochenta y un soles con veinticinco céntimos'), (350.90, 'trescientos cincuenta soles con noventa céntimos'), (100.00, 'cien soles con cero céntimos'), ) TEST_CASES_TO_CURRENCY_CRC = ( (1.00, 'un colón con cero centavos'), (2.00, 'dos colones con cero centavos'), (8.00, 'ocho colones con cero centavos'), (12.00, 'doce colones con cero centavos'), (21.00, 'veintiún colones con cero centavos'), (81.25, 'ochenta y un colones con veinticinco centavos'), (350.90, 'trescientos cincuenta colones con noventa centavos'), (100.00, 'cien colones con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta colones con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_GBP = ( (1.00, 'una libra con cero peniques'), (1.01, 'una libra con un penique'), (2.00, 'dos libras con cero peniques'), (8.00, 'ocho libras con cero peniques'), (12.00, 'doce libras con cero peniques'), (21.00, 'veintiuna libras con cero peniques'), (81.25, 'ochenta y una libras con veinticinco peniques'), (350.90, 'trescientas cincuenta libras con noventa peniques'), (100.00, 'cien libras con cero peniques'), (4150.83, 'cuatro mil ciento cincuenta libras con ochenta y tres peniques'), ) TEST_CASES_TO_CURRENCY_RUB = ( (1.00, 'un rublo con cero kopeykas'), (2.00, 'dos rublos con cero kopeykas'), (8.00, 'ocho rublos con cero kopeykas'), (12.00, 'doce rublos con cero kopeykas'), (21.00, 'veintiún rublos con cero kopeykas'), (81.25, 'ochenta y un rublos con veinticinco kopeykas'), (350.90, 'trescientos cincuenta rublos con noventa kopeykas'), (100.00, 'cien rublos con cero kopeykas'), (4150.83, 'cuatro mil ciento cincuenta rublos con ochenta y tres kopeykas'), ) TEST_CASES_TO_CURRENCY_SEK = ( (1.00, 'una corona con cero öre'), (2.00, 'dos coronas con cero öre'), (8.00, 'ocho coronas con cero öre'), (12.00, 'doce coronas con cero öre'), (21.00, 'veintiuna coronas con cero öre'), (81.25, 'ochenta y una coronas con veinticinco öre'), (350.90, 'trescientas cincuenta coronas con noventa öre'), (100.00, 'cien coronas con cero öre'), (4150.83, 'cuatro mil ciento cincuenta coronas con ochenta y tres öre'), ) TEST_CASES_TO_CURRENCY_NOK = ( (1.00, 'una corona con cero øre'), (2.00, 'dos coronas con cero øre'), (8.00, 'ocho coronas con cero øre'), (12.00, 'doce coronas con cero øre'), (21.00, 'veintiuna coronas con cero øre'), (81.25, 'ochenta y una coronas con veinticinco øre'), (350.90, 'trescientas cincuenta coronas con noventa øre'), (100.00, 'cien coronas con cero øre'), (4150.83, 'cuatro mil ciento cincuenta coronas con ochenta y tres øre'), ) TEST_CASES_TO_CURRENCY_PLN = ( (1.00, 'un zloty con cero groszy'), (2.00, 'dos zlotys con cero groszy'), (8.00, 'ocho zlotys con cero groszy'), (12.00, 'doce zlotys con cero groszy'), (21.00, 'veintiún zlotys con cero groszy'), (81.25, 'ochenta y un zlotys con veinticinco groszy'), (350.90, 'trescientos cincuenta zlotys con noventa groszy'), (100.00, 'cien zlotys con cero groszy'), (4150.83, 'cuatro mil ciento cincuenta zlotys con ochenta y tres groszy'), ) TEST_CASES_TO_CURRENCY_MXN = ( (1.00, 'un peso con cero centavos'), (2.00, 'dos pesos con cero centavos'), (8.00, 'ocho pesos con cero centavos'), (12.00, 'doce pesos con cero centavos'), (21.00, 'veintiún pesos con cero centavos'), (81.25, 'ochenta y un pesos con veinticinco centavos'), (350.90, 'trescientos cincuenta pesos con noventa centavos'), (100.00, 'cien pesos con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta pesos con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_RON = ( (1.00, 'un leu con cero bani'), (2.00, 'dos leus con cero bani'), (8.00, 'ocho leus con cero bani'), (12.00, 'doce leus con cero bani'), (21.00, 'veintiún leus con cero bani'), (81.25, 'ochenta y un leus con veinticinco bani'), (350.90, 'trescientos cincuenta leus con noventa bani'), (100.00, 'cien leus con cero bani'), (4150.83, 'cuatro mil ciento cincuenta leus con ochenta y tres bani'), ) TEST_CASES_TO_CURRENCY_INR = ( (1.00, 'una rupia con cero paisas'), (2.00, 'dos rupias con cero paisas'), (8.00, 'ocho rupias con cero paisas'), (12.00, 'doce rupias con cero paisas'), (21.00, 'veintiuna rupias con cero paisas'), (81.25, 'ochenta y una rupias con veinticinco paisas'), (350.90, 'trescientas cincuenta rupias con noventa paisas'), (100.00, 'cien rupias con cero paisas'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres paisas'), ) TEST_CASES_TO_CURRENCY_HUF = ( (1.00, 'un florín con cero fillér'), (2.00, 'dos florines con cero fillér'), (8.00, 'ocho florines con cero fillér'), (12.00, 'doce florines con cero fillér'), (21.00, 'veintiún florines con cero fillér'), (81.25, 'ochenta y un florines con veinticinco fillér'), (350.90, 'trescientos cincuenta florines con noventa fillér'), (100.00, 'cien florines con cero fillér'), (4150.83, 'cuatro mil ciento cincuenta florines con ochenta y tres fillér'), ) TEST_CASES_TO_CURRENCY_FRF = ( (1.00, 'un franco con cero céntimos'), (2.00, 'dos francos con cero céntimos'), (8.00, 'ocho francos con cero céntimos'), (12.00, 'doce francos con cero céntimos'), (21.00, 'veintiún francos con cero céntimos'), (81.25, 'ochenta y un francos con veinticinco céntimos'), (350.90, 'trescientos cincuenta francos con noventa céntimos'), (100.00, 'cien francos con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta francos con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_CNY = ( (1.00, 'un yuan con cero jiaos'), (2.00, 'dos yuanes con cero jiaos'), (8.00, 'ocho yuanes con cero jiaos'), (12.00, 'doce yuanes con cero jiaos'), (21.00, 'veintiún yuanes con cero jiaos'), (81.25, 'ochenta y un yuanes con veinticinco jiaos'), (350.90, 'trescientos cincuenta yuanes con noventa jiaos'), (100.00, 'cien yuanes con cero jiaos'), (4150.83, 'cuatro mil ciento cincuenta yuanes con ochenta y tres jiaos'), ) TEST_CASES_TO_CURRENCY_CZK = ( (1.00, 'una corona con cero haléř'), (2.00, 'dos coronas con cero haléř'), (8.00, 'ocho coronas con cero haléř'), (12.00, 'doce coronas con cero haléř'), (21.00, 'veintiuna coronas con cero haléř'), (81.25, 'ochenta y una coronas con veinticinco haléř'), (350.90, 'trescientas cincuenta coronas con noventa haléř'), (100.00, 'cien coronas con cero haléř'), (4150.83, 'cuatro mil ciento cincuenta coronas con ochenta y tres haléř'), ) TEST_CASES_TO_CURRENCY_NIO = ( (1.00, 'un córdoba con cero centavos'), (2.00, 'dos córdobas con cero centavos'), (8.00, 'ocho córdobas con cero centavos'), (12.00, 'doce córdobas con cero centavos'), (21.00, 'veintiún córdobas con cero centavos'), (81.25, 'ochenta y un córdobas con veinticinco centavos'), (350.90, 'trescientos cincuenta córdobas con noventa centavos'), (100.00, 'cien córdobas con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta córdobas con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_VES = ( (1.00, 'un bolívar con cero céntimos'), (2.00, 'dos bolívares con cero céntimos'), (8.00, 'ocho bolívares con cero céntimos'), (12.00, 'doce bolívares con cero céntimos'), (21.00, 'veintiún bolívares con cero céntimos'), (81.25, 'ochenta y un bolívares con veinticinco céntimos'), (350.90, 'trescientos cincuenta bolívares con noventa céntimos'), (100.00, 'cien bolívares con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta bolívares con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_BRL = ( (1.00, 'un real con cero centavos'), (2.00, 'dos reales con cero centavos'), (8.00, 'ocho reales con cero centavos'), (12.00, 'doce reales con cero centavos'), (21.00, 'veintiún reales con cero centavos'), (81.25, 'ochenta y un reales con veinticinco centavos'), (350.90, 'trescientos cincuenta reales con noventa centavos'), (100.00, 'cien reales con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta reales con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_JPY = ( (1.00, 'un yen con cero sen'), (2.00, 'dos yenes con cero sen'), (8.00, 'ocho yenes con cero sen'), (12.00, 'doce yenes con cero sen'), (21.00, 'veintiún yenes con cero sen'), (81.25, 'ochenta y un yenes con veinticinco sen'), (350.90, 'trescientos cincuenta yenes con noventa sen'), (100.00, 'cien yenes con cero sen'), (4150.83, 'cuatro mil ciento cincuenta yenes con ochenta y tres sen'), ) TEST_CASES_TO_CURRENCY_KRW = ( (1.00, 'un won con cero jeon'), (2.00, 'dos wones con cero jeon'), (8.00, 'ocho wones con cero jeon'), (12.00, 'doce wones con cero jeon'), (21.00, 'veintiún wones con cero jeon'), (81.25, 'ochenta y un wones con veinticinco jeon'), (350.90, 'trescientos cincuenta wones con noventa jeon'), (100.00, 'cien wones con cero jeon'), (4150.83, 'cuatro mil ciento cincuenta wones con ochenta y tres jeon'), ) TEST_CASES_TO_CURRENCY_KPW = ( (1.00, 'un won con cero chon'), (2.00, 'dos wones con cero chon'), (8.00, 'ocho wones con cero chon'), (12.00, 'doce wones con cero chon'), (21.00, 'veintiún wones con cero chon'), (81.25, 'ochenta y un wones con veinticinco chon'), (350.90, 'trescientos cincuenta wones con noventa chon'), (100.00, 'cien wones con cero chon'), (4150.83, 'cuatro mil ciento cincuenta wones con ochenta y tres chon'), ) TEST_CASES_TO_CURRENCY_TRY = ( (1.00, 'una lira con cero kuruş'), (2.00, 'dos liras con cero kuruş'), (8.00, 'ocho liras con cero kuruş'), (12.00, 'doce liras con cero kuruş'), (21.00, 'veintiuna liras con cero kuruş'), (81.25, 'ochenta y una liras con veinticinco kuruş'), (350.90, 'trescientas cincuenta liras con noventa kuruş'), (100.00, 'cien liras con cero kuruş'), (4150.83, 'cuatro mil ciento cincuenta liras con ochenta y tres kuruş'), ) TEST_CASES_TO_CURRENCY_ZAR = ( (1.00, 'un rand con cero céntimos'), (2.00, 'dos rands con cero céntimos'), (8.00, 'ocho rands con cero céntimos'), (12.00, 'doce rands con cero céntimos'), (21.00, 'veintiún rands con cero céntimos'), (81.25, 'ochenta y un rands con veinticinco céntimos'), (350.90, 'trescientos cincuenta rands con noventa céntimos'), (100.00, 'cien rands con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta rands con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_KZT = ( (1.00, 'un tenge con cero tïın'), (2.00, 'dos tenges con cero tïın'), (8.00, 'ocho tenges con cero tïın'), (12.00, 'doce tenges con cero tïın'), (21.00, 'veintiún tenges con cero tïın'), (81.25, 'ochenta y un tenges con veinticinco tïın'), (350.90, 'trescientos cincuenta tenges con noventa tïın'), (100.00, 'cien tenges con cero tïın'), (4150.83, 'cuatro mil ciento cincuenta tenges con ochenta y tres tïın'), ) TEST_CASES_TO_CURRENCY_UAH = ( (1.00, 'un hryvnia con cero kopiykas'), (2.00, 'dos hryvnias con cero kopiykas'), (8.00, 'ocho hryvnias con cero kopiykas'), (12.00, 'doce hryvnias con cero kopiykas'), (21.00, 'veintiún hryvnias con cero kopiykas'), (81.25, 'ochenta y un hryvnias con veinticinco kopiykas'), (350.90, 'trescientos cincuenta hryvnias con noventa kopiykas'), (100.00, 'cien hryvnias con cero kopiykas'), (4150.83, 'cuatro mil ciento cincuenta hryvnias con ochenta y tres kopiykas'), ) TEST_CASES_TO_CURRENCY_THB = ( (1.00, 'un baht con cero satang'), (2.00, 'dos bahts con cero satang'), (8.00, 'ocho bahts con cero satang'), (12.00, 'doce bahts con cero satang'), (21.00, 'veintiún bahts con cero satang'), (81.25, 'ochenta y un bahts con veinticinco satang'), (350.90, 'trescientos cincuenta bahts con noventa satang'), (100.00, 'cien bahts con cero satang'), (4150.83, 'cuatro mil ciento cincuenta bahts con ochenta y tres satang'), ) TEST_CASES_TO_CURRENCY_AED = ( (1.00, 'un dirham con cero fils'), (2.00, 'dos dirhams con cero fils'), (8.00, 'ocho dirhams con cero fils'), (12.00, 'doce dirhams con cero fils'), (21.00, 'veintiún dirhams con cero fils'), (81.25, 'ochenta y un dirhams con veinticinco fils'), (350.90, 'trescientos cincuenta dirhams con noventa fils'), (100.00, 'cien dirhams con cero fils'), (4150.83, 'cuatro mil ciento cincuenta dirhams con ochenta y tres fils'), ) TEST_CASES_TO_CURRENCY_AFN = ( (1.00, 'un afghani con cero puls'), (2.00, 'dos afghanis con cero puls'), (8.00, 'ocho afghanis con cero puls'), (12.00, 'doce afghanis con cero puls'), (21.00, 'veintiún afghanis con cero puls'), (81.25, 'ochenta y un afghanis con veinticinco puls'), (350.90, 'trescientos cincuenta afghanis con noventa puls'), (100.00, 'cien afghanis con cero puls'), (4150.83, 'cuatro mil ciento cincuenta afghanis con ochenta y tres puls'), ) TEST_CASES_TO_CURRENCY_ALL = ( (1.00, 'un lek con cero qindarka'), (2.00, 'dos leke con cero qindarka'), (8.00, 'ocho leke con cero qindarka'), (12.00, 'doce leke con cero qindarka'), (21.00, 'veintiún leke con cero qindarka'), (81.25, 'ochenta y un leke con veinticinco qindarka'), (350.90, 'trescientos cincuenta leke con noventa qindarka'), (100.00, 'cien leke con cero qindarka'), (4150.83, 'cuatro mil ciento cincuenta leke con ochenta y tres qindarka'), ) TEST_CASES_TO_CURRENCY_AMD = ( (1.00, 'un dram con cero lumas'), (2.00, 'dos drams con cero lumas'), (8.00, 'ocho drams con cero lumas'), (12.00, 'doce drams con cero lumas'), (21.00, 'veintiún drams con cero lumas'), (81.25, 'ochenta y un drams con veinticinco lumas'), (350.90, 'trescientos cincuenta drams con noventa lumas'), (100.00, 'cien drams con cero lumas'), (4150.83, 'cuatro mil ciento cincuenta drams con ochenta y tres lumas'), ) TEST_CASES_TO_CURRENCY_ANG = ( (1.00, 'un florín con cero centavos'), (2.00, 'dos florines con cero centavos'), (8.00, 'ocho florines con cero centavos'), (12.00, 'doce florines con cero centavos'), (21.00, 'veintiún florines con cero centavos'), (81.25, 'ochenta y un florines con veinticinco centavos'), (350.90, 'trescientos cincuenta florines con noventa centavos'), (100.00, 'cien florines con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta florines con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_AOA = ( (1.00, 'un kwanza con cero céntimos'), (2.00, 'dos kwanzas con cero céntimos'), (8.00, 'ocho kwanzas con cero céntimos'), (12.00, 'doce kwanzas con cero céntimos'), (21.00, 'veintiún kwanzas con cero céntimos'), (81.25, 'ochenta y un kwanzas con veinticinco céntimos'), (350.90, 'trescientos cincuenta kwanzas con noventa céntimos'), (100.00, 'cien kwanzas con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta kwanzas con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_AWG = ( (1.00, 'un florín con cero centavos'), (2.00, 'dos florines con cero centavos'), (8.00, 'ocho florines con cero centavos'), (12.00, 'doce florines con cero centavos'), (21.00, 'veintiún florines con cero centavos'), (81.25, 'ochenta y un florines con veinticinco centavos'), (350.90, 'trescientos cincuenta florines con noventa centavos'), (100.00, 'cien florines con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta florines con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_AZN = ( (1.00, 'un manat con cero qəpik'), (2.00, 'dos manat con cero qəpik'), (8.00, 'ocho manat con cero qəpik'), (12.00, 'doce manat con cero qəpik'), (21.00, 'veintiún manat con cero qəpik'), (81.25, 'ochenta y un manat con veinticinco qəpik'), (350.90, 'trescientos cincuenta manat con noventa qəpik'), (100.00, 'cien manat con cero qəpik'), (4150.83, 'cuatro mil ciento cincuenta manat con ochenta y tres qəpik'), ) TEST_CASES_TO_CURRENCY_BDT = ( (1.00, 'un taka con cero paisas'), (2.00, 'dos takas con cero paisas'), (8.00, 'ocho takas con cero paisas'), (12.00, 'doce takas con cero paisas'), (21.00, 'veintiún takas con cero paisas'), (81.25, 'ochenta y un takas con veinticinco paisas'), (350.90, 'trescientos cincuenta takas con noventa paisas'), (100.00, 'cien takas con cero paisas'), (4150.83, 'cuatro mil ciento cincuenta takas con ochenta y tres paisas'), ) TEST_CASES_TO_CURRENCY_BGN = ( (1.00, 'un lev con cero stotinki'), (2.00, 'dos leva con cero stotinki'), (8.00, 'ocho leva con cero stotinki'), (12.00, 'doce leva con cero stotinki'), (21.00, 'veintiún leva con cero stotinki'), (81.25, 'ochenta y un leva con veinticinco stotinki'), (350.90, 'trescientos cincuenta leva con noventa stotinki'), (100.00, 'cien leva con cero stotinki'), (4150.83, 'cuatro mil ciento cincuenta leva con ochenta y tres stotinki'), ) TEST_CASES_TO_CURRENCY_BHD = ( (1.00, 'un dinar con cero fils'), (2.00, 'dos dinares con cero fils'), (8.00, 'ocho dinares con cero fils'), (12.00, 'doce dinares con cero fils'), (21.00, 'veintiún dinares con cero fils'), (81.25, 'ochenta y un dinares con veinticinco fils'), (350.90, 'trescientos cincuenta dinares con noventa fils'), (100.00, 'cien dinares con cero fils'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres fils'), ) TEST_CASES_TO_CURRENCY_BOB = ( (1.00, 'un boliviano con cero centavos'), (2.00, 'dos bolivianos con cero centavos'), (8.00, 'ocho bolivianos con cero centavos'), (12.00, 'doce bolivianos con cero centavos'), (21.00, 'veintiún bolivianos con cero centavos'), (81.25, 'ochenta y un bolivianos con veinticinco centavos'), (350.90, 'trescientos cincuenta bolivianos con noventa centavos'), (100.00, 'cien bolivianos con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta bolivianos con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_BTN = ( (1.00, 'un ngultrum con cero chetrum'), (2.00, 'dos ngultrum con cero chetrum'), (8.00, 'ocho ngultrum con cero chetrum'), (12.00, 'doce ngultrum con cero chetrum'), (21.00, 'veintiún ngultrum con cero chetrum'), (81.25, 'ochenta y un ngultrum con veinticinco chetrum'), (350.90, 'trescientos cincuenta ngultrum con noventa chetrum'), (100.00, 'cien ngultrum con cero chetrum'), (4150.83, 'cuatro mil ciento cincuenta ngultrum con ochenta y tres chetrum'), ) TEST_CASES_TO_CURRENCY_BWP = ( (1.00, 'un pula con cero thebes'), (2.00, 'dos pulas con cero thebes'), (8.00, 'ocho pulas con cero thebes'), (12.00, 'doce pulas con cero thebes'), (21.00, 'veintiún pulas con cero thebes'), (81.25, 'ochenta y un pulas con veinticinco thebes'), (350.90, 'trescientos cincuenta pulas con noventa thebes'), (100.00, 'cien pulas con cero thebes'), (4150.83, 'cuatro mil ciento cincuenta pulas con ochenta y tres thebes'), ) TEST_CASES_TO_CURRENCY_BYN = ( (1.00, 'un rublo con cero kópeks'), (2.00, 'dos rublos con cero kópeks'), (8.00, 'ocho rublos con cero kópeks'), (12.00, 'doce rublos con cero kópeks'), (21.00, 'veintiún rublos con cero kópeks'), (81.25, 'ochenta y un rublos con veinticinco kópeks'), (350.90, 'trescientos cincuenta rublos con noventa kópeks'), (100.00, 'cien rublos con cero kópeks'), (4150.83, 'cuatro mil ciento cincuenta rublos con ochenta y tres kópeks'), ) TEST_CASES_TO_CURRENCY_BYR = ( (1.00, 'un rublo con cero kópeks'), (2.00, 'dos rublos con cero kópeks'), (8.00, 'ocho rublos con cero kópeks'), (12.00, 'doce rublos con cero kópeks'), (21.00, 'veintiún rublos con cero kópeks'), (81.25, 'ochenta y un rublos con veinticinco kópeks'), (350.90, 'trescientos cincuenta rublos con noventa kópeks'), (100.00, 'cien rublos con cero kópeks'), (4150.83, 'cuatro mil ciento cincuenta rublos con ochenta y tres kópeks'), ) TEST_CASES_TO_CURRENCY_BZD = ( (1.00, 'un dólar con cero céntimos'), (2.00, 'dos dólares con cero céntimos'), (8.00, 'ocho dólares con cero céntimos'), (12.00, 'doce dólares con cero céntimos'), (21.00, 'veintiún dólares con cero céntimos'), (81.25, 'ochenta y un dólares con veinticinco céntimos'), (350.90, 'trescientos cincuenta dólares con noventa céntimos'), (100.00, 'cien dólares con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta dólares con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_CVE = ( (1.00, 'un escudo con cero centavos'), (2.00, 'dos escudos con cero centavos'), (8.00, 'ocho escudos con cero centavos'), (12.00, 'doce escudos con cero centavos'), (21.00, 'veintiún escudos con cero centavos'), (81.25, 'ochenta y un escudos con veinticinco centavos'), (350.90, 'trescientos cincuenta escudos con noventa centavos'), (100.00, 'cien escudos con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta escudos con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_CYP = ( (1.00, 'una libra con cero céntimos'), (2.00, 'dos libras con cero céntimos'), (8.00, 'ocho libras con cero céntimos'), (12.00, 'doce libras con cero céntimos'), (21.00, 'veintiuna libras con cero céntimos'), (81.25, 'ochenta y una libras con veinticinco céntimos'), (350.90, 'trescientas cincuenta libras con noventa céntimos'), (100.00, 'cien libras con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta libras con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_DKK = ( (1.00, 'una corona con cero øre'), (2.00, 'dos coronas con cero øre'), (8.00, 'ocho coronas con cero øre'), (12.00, 'doce coronas con cero øre'), (21.00, 'veintiuna coronas con cero øre'), (81.25, 'ochenta y una coronas con veinticinco øre'), (350.90, 'trescientas cincuenta coronas con noventa øre'), (100.00, 'cien coronas con cero øre'), (4150.83, 'cuatro mil ciento cincuenta coronas con ochenta y tres øre'), ) TEST_CASES_TO_CURRENCY_DZD = ( (1.00, 'un dinar con cero céntimos'), (2.00, 'dos dinares con cero céntimos'), (8.00, 'ocho dinares con cero céntimos'), (12.00, 'doce dinares con cero céntimos'), (21.00, 'veintiún dinares con cero céntimos'), (81.25, 'ochenta y un dinares con veinticinco céntimos'), (350.90, 'trescientos cincuenta dinares con noventa céntimos'), (100.00, 'cien dinares con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_ECS = ( (1.00, 'un sucre con cero centavos'), (2.00, 'dos sucres con cero centavos'), (8.00, 'ocho sucres con cero centavos'), (12.00, 'doce sucres con cero centavos'), (21.00, 'veintiún sucres con cero centavos'), (81.25, 'ochenta y un sucres con veinticinco centavos'), (350.90, 'trescientos cincuenta sucres con noventa centavos'), (100.00, 'cien sucres con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta sucres con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_EGP = ( (1.00, 'una libra con cero piastras'), (2.00, 'dos libras con cero piastras'), (8.00, 'ocho libras con cero piastras'), (12.00, 'doce libras con cero piastras'), (21.00, 'veintiuna libras con cero piastras'), (81.21, 'ochenta y una libras con veintiuna piastras'), (81.25, 'ochenta y una libras con veinticinco piastras'), (350.90, 'trescientas cincuenta libras con noventa piastras'), (100.00, 'cien libras con cero piastras'), (4150.83, 'cuatro mil ciento cincuenta libras con ochenta y tres piastras'), ) TEST_CASES_TO_CURRENCY_ERN = ( (1.00, 'un nakfa con cero céntimos'), (2.00, 'dos nakfas con cero céntimos'), (8.00, 'ocho nakfas con cero céntimos'), (12.00, 'doce nakfas con cero céntimos'), (21.00, 'veintiún nakfas con cero céntimos'), (81.25, 'ochenta y un nakfas con veinticinco céntimos'), (350.90, 'trescientos cincuenta nakfas con noventa céntimos'), (100.00, 'cien nakfas con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta nakfas con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_ETB = ( (1.00, 'un birr con cero céntimos'), (2.00, 'dos birrs con cero céntimos'), (8.00, 'ocho birrs con cero céntimos'), (12.00, 'doce birrs con cero céntimos'), (21.00, 'veintiún birrs con cero céntimos'), (81.25, 'ochenta y un birrs con veinticinco céntimos'), (350.90, 'trescientos cincuenta birrs con noventa céntimos'), (100.00, 'cien birrs con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta birrs con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_FKP = ( (1.00, 'una libra con cero peniques'), (2.00, 'dos libras con cero peniques'), (8.00, 'ocho libras con cero peniques'), (12.00, 'doce libras con cero peniques'), (21.00, 'veintiuna libras con cero peniques'), (81.25, 'ochenta y una libras con veinticinco peniques'), (350.90, 'trescientas cincuenta libras con noventa peniques'), (100.00, 'cien libras con cero peniques'), (4150.83, 'cuatro mil ciento cincuenta libras con ochenta y tres peniques'), ) TEST_CASES_TO_CURRENCY_GEL = ( (1.00, 'un lari con cero tetris'), (2.00, 'dos laris con cero tetris'), (8.00, 'ocho laris con cero tetris'), (12.00, 'doce laris con cero tetris'), (21.00, 'veintiún laris con cero tetris'), (81.25, 'ochenta y un laris con veinticinco tetris'), (350.90, 'trescientos cincuenta laris con noventa tetris'), (100.00, 'cien laris con cero tetris'), (4150.83, 'cuatro mil ciento cincuenta laris con ochenta y tres tetris'), ) TEST_CASES_TO_CURRENCY_GHS = ( (1.00, 'un cedi con cero pesewas'), (2.00, 'dos cedis con cero pesewas'), (8.00, 'ocho cedis con cero pesewas'), (12.00, 'doce cedis con cero pesewas'), (21.00, 'veintiún cedis con cero pesewas'), (81.25, 'ochenta y un cedis con veinticinco pesewas'), (350.90, 'trescientos cincuenta cedis con noventa pesewas'), (100.00, 'cien cedis con cero pesewas'), (4150.83, 'cuatro mil ciento cincuenta cedis con ochenta y tres pesewas'), ) TEST_CASES_TO_CURRENCY_GMD = ( (1.00, 'un dalasi con cero bututs'), (2.00, 'dos dalasis con cero bututs'), (8.00, 'ocho dalasis con cero bututs'), (12.00, 'doce dalasis con cero bututs'), (21.00, 'veintiún dalasis con cero bututs'), (81.25, 'ochenta y un dalasis con veinticinco bututs'), (350.90, 'trescientos cincuenta dalasis con noventa bututs'), (100.00, 'cien dalasis con cero bututs'), (4150.83, 'cuatro mil ciento cincuenta dalasis con ochenta y tres bututs'), ) TEST_CASES_TO_CURRENCY_GTQ = ( (1.00, 'un quetzal con cero centavos'), (2.00, 'dos quetzales con cero centavos'), (8.00, 'ocho quetzales con cero centavos'), (12.00, 'doce quetzales con cero centavos'), (21.00, 'veintiún quetzales con cero centavos'), (81.25, 'ochenta y un quetzales con veinticinco centavos'), (350.90, 'trescientos cincuenta quetzales con noventa centavos'), (100.00, 'cien quetzales con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta quetzales con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_HNL = ( (1.00, 'un lempira con cero centavos'), (2.00, 'dos lempiras con cero centavos'), (8.00, 'ocho lempiras con cero centavos'), (12.00, 'doce lempiras con cero centavos'), (21.00, 'veintiún lempiras con cero centavos'), (81.25, 'ochenta y un lempiras con veinticinco centavos'), (350.90, 'trescientos cincuenta lempiras con noventa centavos'), (100.00, 'cien lempiras con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta lempiras con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_HRK = ( (1.00, 'un kuna con cero lipas'), (2.00, 'dos kunas con cero lipas'), (8.00, 'ocho kunas con cero lipas'), (12.00, 'doce kunas con cero lipas'), (21.00, 'veintiún kunas con cero lipas'), (81.25, 'ochenta y un kunas con veinticinco lipas'), (350.90, 'trescientos cincuenta kunas con noventa lipas'), (100.00, 'cien kunas con cero lipas'), (4150.83, 'cuatro mil ciento cincuenta kunas con ochenta y tres lipas'), ) TEST_CASES_TO_CURRENCY_HTG = ( (1.00, 'un gourde con cero céntimos'), (2.00, 'dos gourdes con cero céntimos'), (8.00, 'ocho gourdes con cero céntimos'), (12.00, 'doce gourdes con cero céntimos'), (21.00, 'veintiún gourdes con cero céntimos'), (81.25, 'ochenta y un gourdes con veinticinco céntimos'), (350.90, 'trescientos cincuenta gourdes con noventa céntimos'), (100.00, 'cien gourdes con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta gourdes con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_IDR = ( (1.00, 'una rupia con cero céntimos'), (2.00, 'dos rupias con cero céntimos'), (8.00, 'ocho rupias con cero céntimos'), (12.00, 'doce rupias con cero céntimos'), (21.00, 'veintiuna rupias con cero céntimos'), (81.25, 'ochenta y una rupias con veinticinco céntimos'), (350.90, 'trescientas cincuenta rupias con noventa céntimos'), (100.00, 'cien rupias con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_ILS = ( (1.00, 'un séquel con cero agoras'), (2.00, 'dos séqueles con cero agoras'), (8.00, 'ocho séqueles con cero agoras'), (12.00, 'doce séqueles con cero agoras'), (21.00, 'veintiún séqueles con cero agoras'), (81.25, 'ochenta y un séqueles con veinticinco agoras'), (350.90, 'trescientos cincuenta séqueles con noventa agoras'), (100.00, 'cien séqueles con cero agoras'), (4150.83, 'cuatro mil ciento cincuenta séqueles con ochenta y tres agoras'), ) TEST_CASES_TO_CURRENCY_IQD = ( (1.00, 'un dinar con cero fils'), (2.00, 'dos dinares con cero fils'), (8.00, 'ocho dinares con cero fils'), (12.00, 'doce dinares con cero fils'), (21.00, 'veintiún dinares con cero fils'), (81.25, 'ochenta y un dinares con veinticinco fils'), (350.90, 'trescientos cincuenta dinares con noventa fils'), (100.00, 'cien dinares con cero fils'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres fils'), ) TEST_CASES_TO_CURRENCY_IRR = ( (1.00, 'un rial con cero dinares'), (2.00, 'dos riales con cero dinares'), (8.00, 'ocho riales con cero dinares'), (12.00, 'doce riales con cero dinares'), (21.00, 'veintiún riales con cero dinares'), (81.25, 'ochenta y un riales con veinticinco dinares'), (350.90, 'trescientos cincuenta riales con noventa dinares'), (100.00, 'cien riales con cero dinares'), (4150.83, 'cuatro mil ciento cincuenta riales con ochenta y tres dinares'), ) TEST_CASES_TO_CURRENCY_ISK = ( (1.00, 'una corona con cero aurar'), (2.00, 'dos coronas con cero aurar'), (8.00, 'ocho coronas con cero aurar'), (12.00, 'doce coronas con cero aurar'), (21.00, 'veintiuna coronas con cero aurar'), (81.25, 'ochenta y una coronas con veinticinco aurar'), (350.90, 'trescientas cincuenta coronas con noventa aurar'), (100.00, 'cien coronas con cero aurar'), (4150.83, 'cuatro mil ciento cincuenta coronas con ochenta y tres aurar'), ) TEST_CASES_TO_CURRENCY_ITL = ( (1.00, 'una lira con cero céntimos'), (2.00, 'dos liras con cero céntimos'), (8.00, 'ocho liras con cero céntimos'), (12.00, 'doce liras con cero céntimos'), (21.00, 'veintiuna liras con cero céntimos'), (81.25, 'ochenta y una liras con veinticinco céntimos'), (350.90, 'trescientas cincuenta liras con noventa céntimos'), (100.00, 'cien liras con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta liras con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_JOD = ( (1.00, 'un dinar con cero piastras'), (2.00, 'dos dinares con cero piastras'), (8.00, 'ocho dinares con cero piastras'), (12.00, 'doce dinares con cero piastras'), (21.00, 'veintiún dinares con cero piastras'), (81.25, 'ochenta y un dinares con veinticinco piastras'), (350.90, 'trescientos cincuenta dinares con noventa piastras'), (100.00, 'cien dinares con cero piastras'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres piastras'), ) TEST_CASES_TO_CURRENCY_KES = ( (1.00, 'un chelín con cero céntimos'), (2.00, 'dos chelines con cero céntimos'), (8.00, 'ocho chelines con cero céntimos'), (12.00, 'doce chelines con cero céntimos'), (21.00, 'veintiún chelines con cero céntimos'), (81.25, 'ochenta y un chelines con veinticinco céntimos'), (350.90, 'trescientos cincuenta chelines con noventa céntimos'), (100.00, 'cien chelines con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta chelines con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_KGS = ( (1.00, 'un som con cero tyiyn'), (2.00, 'dos som con cero tyiyn'), (8.00, 'ocho som con cero tyiyn'), (12.00, 'doce som con cero tyiyn'), (21.00, 'veintiún som con cero tyiyn'), (81.25, 'ochenta y un som con veinticinco tyiyn'), (350.90, 'trescientos cincuenta som con noventa tyiyn'), (100.00, 'cien som con cero tyiyn'), (4150.83, 'cuatro mil ciento cincuenta som con ochenta y tres tyiyn'), ) TEST_CASES_TO_CURRENCY_KHR = ( (1.00, 'un riel con cero céntimos'), (2.00, 'dos rieles con cero céntimos'), (8.00, 'ocho rieles con cero céntimos'), (12.00, 'doce rieles con cero céntimos'), (21.00, 'veintiún rieles con cero céntimos'), (81.25, 'ochenta y un rieles con veinticinco céntimos'), (350.90, 'trescientos cincuenta rieles con noventa céntimos'), (100.00, 'cien rieles con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta rieles con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_KWD = ( (1.00, 'un dinar con cero fils'), (2.00, 'dos dinares con cero fils'), (8.00, 'ocho dinares con cero fils'), (12.00, 'doce dinares con cero fils'), (21.00, 'veintiún dinares con cero fils'), (81.25, 'ochenta y un dinares con veinticinco fils'), (350.90, 'trescientos cincuenta dinares con noventa fils'), (100.00, 'cien dinares con cero fils'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres fils'), ) TEST_CASES_TO_CURRENCY_LAK = ( (1.00, 'un kip con cero att'), (2.00, 'dos kips con cero att'), (8.00, 'ocho kips con cero att'), (12.00, 'doce kips con cero att'), (21.00, 'veintiún kips con cero att'), (81.25, 'ochenta y un kips con veinticinco att'), (350.90, 'trescientos cincuenta kips con noventa att'), (100.00, 'cien kips con cero att'), (4150.83, 'cuatro mil ciento cincuenta kips con ochenta y tres att'), ) TEST_CASES_TO_CURRENCY_LKR = ( (1.00, 'una rupia con cero céntimos'), (2.00, 'dos rupias con cero céntimos'), (8.00, 'ocho rupias con cero céntimos'), (12.00, 'doce rupias con cero céntimos'), (21.00, 'veintiuna rupias con cero céntimos'), (81.25, 'ochenta y una rupias con veinticinco céntimos'), (350.90, 'trescientas cincuenta rupias con noventa céntimos'), (100.00, 'cien rupias con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_LSL = ( (1.00, 'un loti con cero céntimos'), (2.00, 'dos lotis con cero céntimos'), (8.00, 'ocho lotis con cero céntimos'), (12.00, 'doce lotis con cero céntimos'), (21.00, 'veintiún lotis con cero céntimos'), (81.25, 'ochenta y un lotis con veinticinco céntimos'), (350.90, 'trescientos cincuenta lotis con noventa céntimos'), (100.00, 'cien lotis con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta lotis con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_LTL = ( (1.00, 'un lita con cero céntimos'), (2.00, 'dos litas con cero céntimos'), (8.00, 'ocho litas con cero céntimos'), (12.00, 'doce litas con cero céntimos'), (21.00, 'veintiún litas con cero céntimos'), (81.25, 'ochenta y un litas con veinticinco céntimos'), (350.90, 'trescientos cincuenta litas con noventa céntimos'), (100.00, 'cien litas con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta litas con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_LVL = ( (1.00, 'un lat con cero céntimos'), (2.00, 'dos lats con cero céntimos'), (8.00, 'ocho lats con cero céntimos'), (12.00, 'doce lats con cero céntimos'), (21.00, 'veintiún lats con cero céntimos'), (81.25, 'ochenta y un lats con veinticinco céntimos'), (350.90, 'trescientos cincuenta lats con noventa céntimos'), (100.00, 'cien lats con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta lats con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_LYD = ( (1.00, 'un dinar con cero dírhams'), (2.00, 'dos dinares con cero dírhams'), (8.00, 'ocho dinares con cero dírhams'), (12.00, 'doce dinares con cero dírhams'), (21.00, 'veintiún dinares con cero dírhams'), (81.25, 'ochenta y un dinares con veinticinco dírhams'), (350.90, 'trescientos cincuenta dinares con noventa dírhams'), (100.00, 'cien dinares con cero dírhams'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres dírhams'), ) TEST_CASES_TO_CURRENCY_MAD = ( (1.00, 'un dírham con cero céntimos'), (2.00, 'dos dirhams con cero céntimos'), (8.00, 'ocho dirhams con cero céntimos'), (12.00, 'doce dirhams con cero céntimos'), (21.00, 'veintiún dirhams con cero céntimos'), (81.25, 'ochenta y un dirhams con veinticinco céntimos'), (350.90, 'trescientos cincuenta dirhams con noventa céntimos'), (100.00, 'cien dirhams con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta dirhams con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_MDL = ( (1.00, 'un leu con cero bani'), (2.00, 'dos lei con cero bani'), (8.00, 'ocho lei con cero bani'), (12.00, 'doce lei con cero bani'), (21.00, 'veintiún lei con cero bani'), (81.25, 'ochenta y un lei con veinticinco bani'), (350.90, 'trescientos cincuenta lei con noventa bani'), (100.00, 'cien lei con cero bani'), (4150.83, 'cuatro mil ciento cincuenta lei con ochenta y tres bani'), ) TEST_CASES_TO_CURRENCY_MGA = ( (1.00, 'un ariary con cero iraimbilanja'), (2.00, 'dos ariaris con cero iraimbilanja'), (8.00, 'ocho ariaris con cero iraimbilanja'), (12.00, 'doce ariaris con cero iraimbilanja'), (21.00, 'veintiún ariaris con cero iraimbilanja'), (81.25, 'ochenta y un ariaris con veinticinco iraimbilanja'), (350.90, 'trescientos cincuenta ariaris con noventa iraimbilanja'), (100.00, 'cien ariaris con cero iraimbilanja'), (4150.83, 'cuatro mil ciento cincuenta ariaris con ochenta y tres iraimbilanja'), ) TEST_CASES_TO_CURRENCY_MKD = ( (1.00, 'un denar con cero denis'), (2.00, 'dos denares con cero denis'), (8.00, 'ocho denares con cero denis'), (12.00, 'doce denares con cero denis'), (21.00, 'veintiún denares con cero denis'), (81.25, 'ochenta y un denares con veinticinco denis'), (350.90, 'trescientos cincuenta denares con noventa denis'), (100.00, 'cien denares con cero denis'), (4150.83, 'cuatro mil ciento cincuenta denares con ochenta y tres denis'), ) TEST_CASES_TO_CURRENCY_MMK = ( (1.00, 'un kiat con cero pyas'), (2.00, 'dos kiats con cero pyas'), (8.00, 'ocho kiats con cero pyas'), (12.00, 'doce kiats con cero pyas'), (21.00, 'veintiún kiats con cero pyas'), (81.25, 'ochenta y un kiats con veinticinco pyas'), (350.90, 'trescientos cincuenta kiats con noventa pyas'), (100.00, 'cien kiats con cero pyas'), (4150.83, 'cuatro mil ciento cincuenta kiats con ochenta y tres pyas'), ) TEST_CASES_TO_CURRENCY_MNT = ( (1.00, 'un tugrik con cero möngö'), (2.00, 'dos tugriks con cero möngö'), (8.00, 'ocho tugriks con cero möngö'), (12.00, 'doce tugriks con cero möngö'), (21.00, 'veintiún tugriks con cero möngö'), (81.25, 'ochenta y un tugriks con veinticinco möngö'), (350.90, 'trescientos cincuenta tugriks con noventa möngö'), (100.00, 'cien tugriks con cero möngö'), (4150.83, 'cuatro mil ciento cincuenta tugriks con ochenta y tres möngö'), ) TEST_CASES_TO_CURRENCY_MOP = ( (1.00, 'un pataca con cero avos'), (2.00, 'dos patacas con cero avos'), (8.00, 'ocho patacas con cero avos'), (12.00, 'doce patacas con cero avos'), (21.00, 'veintiún patacas con cero avos'), (81.25, 'ochenta y un patacas con veinticinco avos'), (350.90, 'trescientos cincuenta patacas con noventa avos'), (100.00, 'cien patacas con cero avos'), (4150.83, 'cuatro mil ciento cincuenta patacas con ochenta y tres avos'), ) TEST_CASES_TO_CURRENCY_MRO = ( (1.00, 'un ouguiya con cero khoums'), (2.00, 'dos ouguiyas con cero khoums'), (8.00, 'ocho ouguiyas con cero khoums'), (12.00, 'doce ouguiyas con cero khoums'), (21.00, 'veintiún ouguiyas con cero khoums'), (81.25, 'ochenta y un ouguiyas con veinticinco khoums'), (350.90, 'trescientos cincuenta ouguiyas con noventa khoums'), (100.00, 'cien ouguiyas con cero khoums'), (4150.83, 'cuatro mil ciento cincuenta ouguiyas con ochenta y tres khoums'), ) TEST_CASES_TO_CURRENCY_MRU = ( (1.00, 'un ouguiya con cero khoums'), (2.00, 'dos ouguiyas con cero khoums'), (8.00, 'ocho ouguiyas con cero khoums'), (12.00, 'doce ouguiyas con cero khoums'), (21.00, 'veintiún ouguiyas con cero khoums'), (81.25, 'ochenta y un ouguiyas con veinticinco khoums'), (350.90, 'trescientos cincuenta ouguiyas con noventa khoums'), (100.00, 'cien ouguiyas con cero khoums'), (4150.83, 'cuatro mil ciento cincuenta ouguiyas con ochenta y tres khoums'), ) TEST_CASES_TO_CURRENCY_MUR = ( (1.00, 'una rupia con cero céntimos'), (2.00, 'dos rupias con cero céntimos'), (8.00, 'ocho rupias con cero céntimos'), (12.00, 'doce rupias con cero céntimos'), (21.00, 'veintiuna rupias con cero céntimos'), (81.25, 'ochenta y una rupias con veinticinco céntimos'), (350.90, 'trescientas cincuenta rupias con noventa céntimos'), (100.00, 'cien rupias con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_MVR = ( (1.00, 'un rufiyaa con cero laari'), (2.00, 'dos rufiyaas con cero laari'), (8.00, 'ocho rufiyaas con cero laari'), (12.00, 'doce rufiyaas con cero laari'), (21.00, 'veintiún rufiyaas con cero laari'), (81.25, 'ochenta y un rufiyaas con veinticinco laari'), (350.90, 'trescientos cincuenta rufiyaas con noventa laari'), (100.00, 'cien rufiyaas con cero laari'), (4150.83, 'cuatro mil ciento cincuenta rufiyaas con ochenta y tres laari'), ) TEST_CASES_TO_CURRENCY_MWK = ( (1.00, 'un kuacha con cero tambalas'), (2.00, 'dos kuachas con cero tambalas'), (8.00, 'ocho kuachas con cero tambalas'), (12.00, 'doce kuachas con cero tambalas'), (21.00, 'veintiún kuachas con cero tambalas'), (81.25, 'ochenta y un kuachas con veinticinco tambalas'), (350.90, 'trescientos cincuenta kuachas con noventa tambalas'), (100.00, 'cien kuachas con cero tambalas'), (4150.83, 'cuatro mil ciento cincuenta kuachas con ochenta y tres tambalas'), ) TEST_CASES_TO_CURRENCY_MYR = ( (1.00, 'un ringgit con cero céntimos'), (2.00, 'dos ringgit con cero céntimos'), (8.00, 'ocho ringgit con cero céntimos'), (12.00, 'doce ringgit con cero céntimos'), (21.00, 'veintiún ringgit con cero céntimos'), (81.25, 'ochenta y un ringgit con veinticinco céntimos'), (350.90, 'trescientos cincuenta ringgit con noventa céntimos'), (100.00, 'cien ringgit con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta ringgit con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_MZN = ( (1.00, 'un metical con cero centavos'), (2.00, 'dos metical con cero centavos'), (8.00, 'ocho metical con cero centavos'), (12.00, 'doce metical con cero centavos'), (21.00, 'veintiún metical con cero centavos'), (81.25, 'ochenta y un metical con veinticinco centavos'), (350.90, 'trescientos cincuenta metical con noventa centavos'), (100.00, 'cien metical con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta metical con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_NGN = ( (1.00, 'un naira con cero kobo'), (2.00, 'dos nairas con cero kobo'), (8.00, 'ocho nairas con cero kobo'), (12.00, 'doce nairas con cero kobo'), (21.00, 'veintiún nairas con cero kobo'), (81.25, 'ochenta y un nairas con veinticinco kobo'), (350.90, 'trescientos cincuenta nairas con noventa kobo'), (100.00, 'cien nairas con cero kobo'), (4150.83, 'cuatro mil ciento cincuenta nairas con ochenta y tres kobo'), ) TEST_CASES_TO_CURRENCY_NPR = ( (1.00, 'una rupia con cero paisas'), (2.00, 'dos rupias con cero paisas'), (8.00, 'ocho rupias con cero paisas'), (12.00, 'doce rupias con cero paisas'), (21.00, 'veintiuna rupias con cero paisas'), (81.25, 'ochenta y una rupias con veinticinco paisas'), (350.90, 'trescientas cincuenta rupias con noventa paisas'), (100.00, 'cien rupias con cero paisas'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres paisas'), ) TEST_CASES_TO_CURRENCY_OMR = ( (1.00, 'un rial con cero baisa'), (2.00, 'dos riales con cero baisa'), (8.00, 'ocho riales con cero baisa'), (12.00, 'doce riales con cero baisa'), (21.00, 'veintiún riales con cero baisa'), (81.25, 'ochenta y un riales con veinticinco baisa'), (350.90, 'trescientos cincuenta riales con noventa baisa'), (100.00, 'cien riales con cero baisa'), (4150.83, 'cuatro mil ciento cincuenta riales con ochenta y tres baisa'), ) TEST_CASES_TO_CURRENCY_PAB = ( (1.00, 'un balboa con cero centésimos'), (2.00, 'dos balboas con cero centésimos'), (8.00, 'ocho balboas con cero centésimos'), (12.00, 'doce balboas con cero centésimos'), (21.00, 'veintiún balboas con cero centésimos'), (81.25, 'ochenta y un balboas con veinticinco centésimos'), (350.90, 'trescientos cincuenta balboas con noventa centésimos'), (100.00, 'cien balboas con cero centésimos'), (4150.83, 'cuatro mil ciento cincuenta balboas con ochenta y tres centésimos'), ) TEST_CASES_TO_CURRENCY_PGK = ( (1.00, 'un kina con cero toea'), (2.00, 'dos kinas con cero toea'), (8.00, 'ocho kinas con cero toea'), (12.00, 'doce kinas con cero toea'), (21.00, 'veintiún kinas con cero toea'), (81.25, 'ochenta y un kinas con veinticinco toea'), (350.90, 'trescientos cincuenta kinas con noventa toea'), (100.00, 'cien kinas con cero toea'), (4150.83, 'cuatro mil ciento cincuenta kinas con ochenta y tres toea'), ) TEST_CASES_TO_CURRENCY_PKR = ( (1.00, 'una rupia con cero paisas'), (2.00, 'dos rupias con cero paisas'), (8.00, 'ocho rupias con cero paisas'), (12.00, 'doce rupias con cero paisas'), (21.00, 'veintiuna rupias con cero paisas'), (81.25, 'ochenta y una rupias con veinticinco paisas'), (350.90, 'trescientas cincuenta rupias con noventa paisas'), (100.00, 'cien rupias con cero paisas'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres paisas'), ) TEST_CASES_TO_CURRENCY_PLZ = ( (1.00, 'un zloty con cero groszy'), (2.00, 'dos zlotys con cero groszy'), (8.00, 'ocho zlotys con cero groszy'), (12.00, 'doce zlotys con cero groszy'), (21.00, 'veintiún zlotys con cero groszy'), (81.25, 'ochenta y un zlotys con veinticinco groszy'), (350.90, 'trescientos cincuenta zlotys con noventa groszy'), (100.00, 'cien zlotys con cero groszy'), (4150.83, 'cuatro mil ciento cincuenta zlotys con ochenta y tres groszy'), ) TEST_CASES_TO_CURRENCY_PYG = ( (1.00, 'un guaraní con cero céntimos'), (2.00, 'dos guaranís con cero céntimos'), (8.00, 'ocho guaranís con cero céntimos'), (12.00, 'doce guaranís con cero céntimos'), (21.00, 'veintiún guaranís con cero céntimos'), (81.25, 'ochenta y un guaranís con veinticinco céntimos'), (350.90, 'trescientos cincuenta guaranís con noventa céntimos'), (100.00, 'cien guaranís con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta guaranís con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_QAR = ( (1.00, 'un rial con cero dírhams'), (2.00, 'dos riales con cero dírhams'), (8.00, 'ocho riales con cero dírhams'), (12.00, 'doce riales con cero dírhams'), (21.00, 'veintiún riales con cero dírhams'), (81.25, 'ochenta y un riales con veinticinco dírhams'), (350.90, 'trescientos cincuenta riales con noventa dírhams'), (100.00, 'cien riales con cero dírhams'), (4150.83, 'cuatro mil ciento cincuenta riales con ochenta y tres dírhams'), ) TEST_CASES_TO_CURRENCY_RSD = ( (1.00, 'un dinar con cero para'), (2.00, 'dos dinares con cero para'), (8.00, 'ocho dinares con cero para'), (12.00, 'doce dinares con cero para'), (21.00, 'veintiún dinares con cero para'), (81.25, 'ochenta y un dinares con veinticinco para'), (350.90, 'trescientos cincuenta dinares con noventa para'), (100.00, 'cien dinares con cero para'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres para'), ) TEST_CASES_TO_CURRENCY_RUR = ( (1.00, 'un rublo con cero kopeks'), (2.00, 'dos rublos con cero kopeks'), (8.00, 'ocho rublos con cero kopeks'), (12.00, 'doce rublos con cero kopeks'), (21.00, 'veintiún rublos con cero kopeks'), (81.25, 'ochenta y un rublos con veinticinco kopeks'), (350.90, 'trescientos cincuenta rublos con noventa kopeks'), (100.00, 'cien rublos con cero kopeks'), (4150.83, 'cuatro mil ciento cincuenta rublos con ochenta y tres kopeks'), ) TEST_CASES_TO_CURRENCY_SAR = ( (1.00, 'un riyal con cero halalas'), (2.00, 'dos riales con cero halalas'), (8.00, 'ocho riales con cero halalas'), (12.00, 'doce riales con cero halalas'), (21.00, 'veintiún riales con cero halalas'), (81.25, 'ochenta y un riales con veinticinco halalas'), (350.90, 'trescientos cincuenta riales con noventa halalas'), (100.00, 'cien riales con cero halalas'), (4150.83, 'cuatro mil ciento cincuenta riales con ochenta y tres halalas'), ) TEST_CASES_TO_CURRENCY_SCR = ( (1.00, 'una rupia con cero céntimos'), (2.00, 'dos rupias con cero céntimos'), (8.00, 'ocho rupias con cero céntimos'), (12.00, 'doce rupias con cero céntimos'), (21.00, 'veintiuna rupias con cero céntimos'), (81.25, 'ochenta y una rupias con veinticinco céntimos'), (350.90, 'trescientas cincuenta rupias con noventa céntimos'), (100.00, 'cien rupias con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta rupias con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_SHP = ( (1.00, 'una libra con cero peniques'), (2.00, 'dos libras con cero peniques'), (8.00, 'ocho libras con cero peniques'), (12.00, 'doce libras con cero peniques'), (21.00, 'veintiuna libras con cero peniques'), (81.25, 'ochenta y una libras con veinticinco peniques'), (350.90, 'trescientas cincuenta libras con noventa peniques'), (100.00, 'cien libras con cero peniques'), (4150.83, 'cuatro mil ciento cincuenta libras con ochenta y tres peniques'), ) TEST_CASES_TO_CURRENCY_SKK = ( (1.00, 'una corona con cero haliers'), (2.00, 'dos coronas con cero haliers'), (8.00, 'ocho coronas con cero haliers'), (12.00, 'doce coronas con cero haliers'), (21.00, 'veintiuna coronas con cero haliers'), (81.25, 'ochenta y una coronas con veinticinco haliers'), (350.90, 'trescientas cincuenta coronas con noventa haliers'), (100.00, 'cien coronas con cero haliers'), (4150.83, 'cuatro mil ciento cincuenta coronas con ochenta y tres haliers'), ) TEST_CASES_TO_CURRENCY_SLL = ( (1.00, 'una leona con cero céntimos'), (2.00, 'dos leonas con cero céntimos'), (8.00, 'ocho leonas con cero céntimos'), (12.00, 'doce leonas con cero céntimos'), (21.00, 'veintiuna leonas con cero céntimos'), (81.25, 'ochenta y una leonas con veinticinco céntimos'), (350.90, 'trescientas cincuenta leonas con noventa céntimos'), (100.00, 'cien leonas con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta leonas con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_STD = ( (1.00, 'un dobra con cero céntimos'), (2.00, 'dos dobras con cero céntimos'), (8.00, 'ocho dobras con cero céntimos'), (12.00, 'doce dobras con cero céntimos'), (21.00, 'veintiún dobras con cero céntimos'), (81.25, 'ochenta y un dobras con veinticinco céntimos'), (350.90, 'trescientos cincuenta dobras con noventa céntimos'), (100.00, 'cien dobras con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta dobras con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_SVC = ( (1.00, 'un colón con cero centavos'), (2.00, 'dos colones con cero centavos'), (8.00, 'ocho colones con cero centavos'), (12.00, 'doce colones con cero centavos'), (21.00, 'veintiún colones con cero centavos'), (81.25, 'ochenta y un colones con veinticinco centavos'), (350.90, 'trescientos cincuenta colones con noventa centavos'), (100.00, 'cien colones con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta colones con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_SZL = ( (1.00, 'un lilangeni con cero céntimos'), (2.00, 'dos emalangeni con cero céntimos'), (8.00, 'ocho emalangeni con cero céntimos'), (12.00, 'doce emalangeni con cero céntimos'), (21.00, 'veintiún emalangeni con cero céntimos'), (81.25, 'ochenta y un emalangeni con veinticinco céntimos'), (350.90, 'trescientos cincuenta emalangeni con noventa céntimos'), (100.00, 'cien emalangeni con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta emalangeni con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_TJS = ( (1.00, 'un somoni con cero dirames'), (2.00, 'dos somonis con cero dirames'), (8.00, 'ocho somonis con cero dirames'), (12.00, 'doce somonis con cero dirames'), (21.00, 'veintiún somonis con cero dirames'), (81.25, 'ochenta y un somonis con veinticinco dirames'), (350.90, 'trescientos cincuenta somonis con noventa dirames'), (100.00, 'cien somonis con cero dirames'), (4150.83, 'cuatro mil ciento cincuenta somonis con ochenta y tres dirames'), ) TEST_CASES_TO_CURRENCY_TMT = ( (1.00, 'un manat con cero tenge'), (2.00, 'dos manat con cero tenge'), (8.00, 'ocho manat con cero tenge'), (12.00, 'doce manat con cero tenge'), (21.00, 'veintiún manat con cero tenge'), (81.25, 'ochenta y un manat con veinticinco tenge'), (350.90, 'trescientos cincuenta manat con noventa tenge'), (100.00, 'cien manat con cero tenge'), (4150.83, 'cuatro mil ciento cincuenta manat con ochenta y tres tenge'), ) TEST_CASES_TO_CURRENCY_TND = ( (1.00, 'un dinar con cero milésimos'), (2.00, 'dos dinares con cero milésimos'), (8.00, 'ocho dinares con cero milésimos'), (12.00, 'doce dinares con cero milésimos'), (21.00, 'veintiún dinares con cero milésimos'), (81.25, 'ochenta y un dinares con veinticinco milésimos'), (350.90, 'trescientos cincuenta dinares con noventa milésimos'), (100.00, 'cien dinares con cero milésimos'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres milésimos'), ) TEST_CASES_TO_CURRENCY_TOP = ( (1.00, 'un paanga con cero céntimos'), (2.00, 'dos paangas con cero céntimos'), (8.00, 'ocho paangas con cero céntimos'), (12.00, 'doce paangas con cero céntimos'), (21.00, 'veintiún paangas con cero céntimos'), (81.25, 'ochenta y un paangas con veinticinco céntimos'), (350.90, 'trescientos cincuenta paangas con noventa céntimos'), (100.00, 'cien paangas con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta paangas con ochenta y tres céntimos'), ) wordamount = "{} {}".format("cuatro mil ciento cincuenta", "nuevos dólares con ochenta y tres céntimos") TEST_CASES_TO_CURRENCY_TWD = ( (1.00, 'un nuevo dólar con cero céntimos'), (2.00, 'dos nuevos dólares con cero céntimos'), (8.00, 'ocho nuevos dólares con cero céntimos'), (12.00, 'doce nuevos dólares con cero céntimos'), (21.00, 'veintiún nuevos dólares con cero céntimos'), (81.25, 'ochenta y un nuevos dólares con veinticinco céntimos'), (350.90, 'trescientos cincuenta nuevos dólares con noventa céntimos'), (100.00, 'cien nuevos dólares con cero céntimos'), (4150.83, wordamount), ) TEST_CASES_TO_CURRENCY_TZS = ( (1.00, 'un chelín con cero céntimos'), (2.00, 'dos chelines con cero céntimos'), (8.00, 'ocho chelines con cero céntimos'), (12.00, 'doce chelines con cero céntimos'), (21.00, 'veintiún chelines con cero céntimos'), (81.25, 'ochenta y un chelines con veinticinco céntimos'), (350.90, 'trescientos cincuenta chelines con noventa céntimos'), (100.00, 'cien chelines con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta chelines con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_UAG = ( (1.00, 'un hryvnia con cero kopiykas'), (2.00, 'dos hryvnias con cero kopiykas'), (8.00, 'ocho hryvnias con cero kopiykas'), (12.00, 'doce hryvnias con cero kopiykas'), (21.00, 'veintiún hryvnias con cero kopiykas'), (81.25, 'ochenta y un hryvnias con veinticinco kopiykas'), (350.90, 'trescientos cincuenta hryvnias con noventa kopiykas'), (100.00, 'cien hryvnias con cero kopiykas'), (4150.83, 'cuatro mil ciento cincuenta hryvnias con ochenta y tres kopiykas'), ) TEST_CASES_TO_CURRENCY_UGX = ( (1.00, 'un chelín con cero céntimos'), (2.00, 'dos chelines con cero céntimos'), (8.00, 'ocho chelines con cero céntimos'), (12.00, 'doce chelines con cero céntimos'), (21.00, 'veintiún chelines con cero céntimos'), (81.25, 'ochenta y un chelines con veinticinco céntimos'), (350.90, 'trescientos cincuenta chelines con noventa céntimos'), (100.00, 'cien chelines con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta chelines con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_UYU = ( (1.00, 'un peso con cero centésimos'), (2.00, 'dos pesos con cero centésimos'), (8.00, 'ocho pesos con cero centésimos'), (12.00, 'doce pesos con cero centésimos'), (21.00, 'veintiún pesos con cero centésimos'), (81.25, 'ochenta y un pesos con veinticinco centésimos'), (350.90, 'trescientos cincuenta pesos con noventa centésimos'), (100.00, 'cien pesos con cero centésimos'), (4150.83, 'cuatro mil ciento cincuenta pesos con ochenta y tres centésimos'), ) TEST_CASES_TO_CURRENCY_UZS = ( (1.00, 'un sum con cero tiyin'), (2.00, 'dos sum con cero tiyin'), (8.00, 'ocho sum con cero tiyin'), (12.00, 'doce sum con cero tiyin'), (21.00, 'veintiún sum con cero tiyin'), (81.25, 'ochenta y un sum con veinticinco tiyin'), (350.90, 'trescientos cincuenta sum con noventa tiyin'), (100.00, 'cien sum con cero tiyin'), (4150.83, 'cuatro mil ciento cincuenta sum con ochenta y tres tiyin'), ) wordamount = "{} {}".format("cuatro mil ciento cincuenta", "bolívares fuertes con ochenta y tres céntimos") TEST_CASES_TO_CURRENCY_VEF = ( (1.00, 'un bolívar fuerte con cero céntimos'), (2.00, 'dos bolívares fuertes con cero céntimos'), (8.00, 'ocho bolívares fuertes con cero céntimos'), (12.00, 'doce bolívares fuertes con cero céntimos'), (21.00, 'veintiún bolívares fuertes con cero céntimos'), (81.25, 'ochenta y un bolívares fuertes con veinticinco céntimos'), (350.90, 'trescientos cincuenta bolívares fuertes con noventa céntimos'), (100.00, 'cien bolívares fuertes con cero céntimos'), (4150.83, wordamount), ) TEST_CASES_TO_CURRENCY_VND = ( (1.00, 'un dong con cero xu'), (2.00, 'dos dongs con cero xu'), (8.00, 'ocho dongs con cero xu'), (12.00, 'doce dongs con cero xu'), (21.00, 'veintiún dongs con cero xu'), (81.25, 'ochenta y un dongs con veinticinco xu'), (350.90, 'trescientos cincuenta dongs con noventa xu'), (100.00, 'cien dongs con cero xu'), (4150.83, 'cuatro mil ciento cincuenta dongs con ochenta y tres xu'), ) TEST_CASES_TO_CURRENCY_VUV = ( (1.00, 'un vatu con cero nenhum'), (2.00, 'dos vatu con cero nenhum'), (8.00, 'ocho vatu con cero nenhum'), (12.00, 'doce vatu con cero nenhum'), (21.00, 'veintiún vatu con cero nenhum'), (81.25, 'ochenta y un vatu con veinticinco nenhum'), (350.90, 'trescientos cincuenta vatu con noventa nenhum'), (100.00, 'cien vatu con cero nenhum'), (4150.83, 'cuatro mil ciento cincuenta vatu con ochenta y tres nenhum'), ) TEST_CASES_TO_CURRENCY_WST = ( (1.00, 'un tala con cero centavos'), (2.00, 'dos tala con cero centavos'), (8.00, 'ocho tala con cero centavos'), (12.00, 'doce tala con cero centavos'), (21.00, 'veintiún tala con cero centavos'), (81.25, 'ochenta y un tala con veinticinco centavos'), (350.90, 'trescientos cincuenta tala con noventa centavos'), (100.00, 'cien tala con cero centavos'), (4150.83, 'cuatro mil ciento cincuenta tala con ochenta y tres centavos'), ) TEST_CASES_TO_CURRENCY_XAF = ( (1.00, 'un franco CFA con cero céntimos'), (2.00, 'dos francos CFA con cero céntimos'), (8.00, 'ocho francos CFA con cero céntimos'), (12.00, 'doce francos CFA con cero céntimos'), (21.00, 'veintiún francos CFA con cero céntimos'), (81.25, 'ochenta y un francos CFA con veinticinco céntimos'), (350.90, 'trescientos cincuenta francos CFA con noventa céntimos'), (100.00, 'cien francos CFA con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta francos CFA con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_XPF = ( (1.00, 'un franco CFP con cero céntimos'), (2.00, 'dos francos CFP con cero céntimos'), (8.00, 'ocho francos CFP con cero céntimos'), (12.00, 'doce francos CFP con cero céntimos'), (21.00, 'veintiún francos CFP con cero céntimos'), (81.25, 'ochenta y un francos CFP con veinticinco céntimos'), (350.90, 'trescientos cincuenta francos CFP con noventa céntimos'), (100.00, 'cien francos CFP con cero céntimos'), (4150.83, 'cuatro mil ciento cincuenta francos CFP con ochenta y tres céntimos'), ) TEST_CASES_TO_CURRENCY_YER = ( (1.00, 'un rial con cero fils'), (2.00, 'dos riales con cero fils'), (8.00, 'ocho riales con cero fils'), (12.00, 'doce riales con cero fils'), (21.00, 'veintiún riales con cero fils'), (81.25, 'ochenta y un riales con veinticinco fils'), (350.90, 'trescientos cincuenta riales con noventa fils'), (100.00, 'cien riales con cero fils'), (4150.83, 'cuatro mil ciento cincuenta riales con ochenta y tres fils'), ) TEST_CASES_TO_CURRENCY_YUM = ( (1.00, 'un dinar con cero para'), (2.00, 'dos dinares con cero para'), (8.00, 'ocho dinares con cero para'), (12.00, 'doce dinares con cero para'), (21.00, 'veintiún dinares con cero para'), (81.25, 'ochenta y un dinares con veinticinco para'), (350.90, 'trescientos cincuenta dinares con noventa para'), (100.00, 'cien dinares con cero para'), (4150.83, 'cuatro mil ciento cincuenta dinares con ochenta y tres para'), ) TEST_CASES_TO_CURRENCY_ZMW = ( (1.00, 'un kwacha con cero ngwee'), (2.00, 'dos kwachas con cero ngwee'), (8.00, 'ocho kwachas con cero ngwee'), (12.00, 'doce kwachas con cero ngwee'), (21.00, 'veintiún kwachas con cero ngwee'), (81.25, 'ochenta y un kwachas con veinticinco ngwee'), (350.90, 'trescientos cincuenta kwachas con noventa ngwee'), (100.00, 'cien kwachas con cero ngwee'), (4150.83, 'cuatro mil ciento cincuenta kwachas con ochenta y tres ngwee'), ) TEST_CASES_TO_CURRENCY_ZRZ = ( (1.00, 'un zaire con cero makuta'), (2.00, 'dos zaires con cero makuta'), (8.00, 'ocho zaires con cero makuta'), (12.00, 'doce zaires con cero makuta'), (21.00, 'veintiún zaires con cero makuta'), (81.25, 'ochenta y un zaires con veinticinco makuta'), (350.90, 'trescientos cincuenta zaires con noventa makuta'), (100.00, 'cien zaires con cero makuta'), (4150.83, 'cuatro mil ciento cincuenta zaires con ochenta y tres makuta'), ) class Num2WordsESTest(TestCase): def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='es'), test[1]) def test_ordinal(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='es', ordinal=True), test[1] ) def test_ordinal_num(self): for test in TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='es', to='ordinal_num'), test[1] ) def test_currency(self): for test in TEST_CASES_TO_CURRENCY: self.assertEqual( num2words(test[0], lang='es', to='currency'), test[1] ) def test_currency_esp(self): for test in TEST_CASES_TO_CURRENCY_ESP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ESP'), test[1] ) def test_currency_usd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='USD'), test[1] ) def test_currency_pen(self): for test in TEST_CASES_TO_CURRENCY_PEN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PEN'), test[1] ) def test_currency_crc(self): for test in TEST_CASES_TO_CURRENCY_CRC: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CRC'), test[1] ) def test_currency_aud(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AUD'), test[1] ) def test_currency_cad(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CAD'), test[1] ) def test_currency_gbp(self): for test in TEST_CASES_TO_CURRENCY_GBP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GBP'), test[1] ) def test_currency_rub(self): for test in TEST_CASES_TO_CURRENCY_RUB: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='RUB'), test[1] ) def test_currency_sek(self): for test in TEST_CASES_TO_CURRENCY_SEK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SEK'), test[1] ) def test_currency_nok(self): for test in TEST_CASES_TO_CURRENCY_NOK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='NOK'), test[1] ) def test_currency_pln(self): for test in TEST_CASES_TO_CURRENCY_PLN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PLN'), test[1] ) def test_currency_mxn(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MXN'), test[1] ) def test_currency_ron(self): for test in TEST_CASES_TO_CURRENCY_RON: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='RON'), test[1] ) def test_currency_inr(self): for test in TEST_CASES_TO_CURRENCY_INR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='INR'), test[1] ) def test_currency_huf(self): for test in TEST_CASES_TO_CURRENCY_HUF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='HUF'), test[1] ) def test_currency_frf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='FRF'), test[1] ) def test_currency_cny(self): for test in TEST_CASES_TO_CURRENCY_CNY: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CNY'), test[1] ) def test_currency_czk(self): for test in TEST_CASES_TO_CURRENCY_CZK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CZK'), test[1] ) def test_currency_nio(self): for test in TEST_CASES_TO_CURRENCY_NIO: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='NIO'), test[1] ) def test_currency_ves(self): for test in TEST_CASES_TO_CURRENCY_VES: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='VES'), test[1] ) def test_currency_brl(self): for test in TEST_CASES_TO_CURRENCY_BRL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BRL'), test[1] ) def test_currency_chf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CHF'), test[1] ) def test_currency_jpy(self): for test in TEST_CASES_TO_CURRENCY_JPY: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='JPY'), test[1] ) def test_currency_krw(self): for test in TEST_CASES_TO_CURRENCY_KRW: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KRW'), test[1] ) def test_currency_kpw(self): for test in TEST_CASES_TO_CURRENCY_KPW: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KPW'), test[1] ) def test_currency_try(self): for test in TEST_CASES_TO_CURRENCY_TRY: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TRY'), test[1] ) def test_currency_zar(self): for test in TEST_CASES_TO_CURRENCY_ZAR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ZAR'), test[1] ) def test_currency_kzt(self): for test in TEST_CASES_TO_CURRENCY_KZT: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KZT'), test[1] ) def test_currency_uah(self): for test in TEST_CASES_TO_CURRENCY_UAH: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='UAH'), test[1] ) def test_currency_thb(self): for test in TEST_CASES_TO_CURRENCY_THB: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='THB'), test[1] ) def test_currency_aed(self): for test in TEST_CASES_TO_CURRENCY_AED: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AED'), test[1] ) def test_currency_afn(self): for test in TEST_CASES_TO_CURRENCY_AFN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AFN'), test[1] ) def test_currency_all(self): for test in TEST_CASES_TO_CURRENCY_ALL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ALL'), test[1] ) def test_currency_amd(self): for test in TEST_CASES_TO_CURRENCY_AMD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AMD'), test[1] ) def test_currency_ang(self): for test in TEST_CASES_TO_CURRENCY_ANG: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ANG'), test[1] ) def test_currency_aoa(self): for test in TEST_CASES_TO_CURRENCY_AOA: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AOA'), test[1] ) def test_currency_ars(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ARS'), test[1] ) def test_currency_awg(self): for test in TEST_CASES_TO_CURRENCY_AWG: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AWG'), test[1] ) def test_currency_azn(self): for test in TEST_CASES_TO_CURRENCY_AZN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='AZN'), test[1] ) def test_currency_bbd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BBD'), test[1] ) def test_currency_bdt(self): for test in TEST_CASES_TO_CURRENCY_BDT: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BDT'), test[1] ) def test_currency_bgn(self): for test in TEST_CASES_TO_CURRENCY_BGN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BGN'), test[1] ) def test_currency_bhd(self): for test in TEST_CASES_TO_CURRENCY_BHD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BHD'), test[1] ) def test_currency_bif(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BIF'), test[1] ) def test_currency_bmd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BMD'), test[1] ) def test_currency_bnd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BND'), test[1] ) def test_currency_bob(self): for test in TEST_CASES_TO_CURRENCY_BOB: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BOB'), test[1] ) def test_currency_bsd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BSD'), test[1] ) def test_currency_btn(self): for test in TEST_CASES_TO_CURRENCY_BTN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BTN'), test[1] ) def test_currency_bwp(self): for test in TEST_CASES_TO_CURRENCY_BWP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BWP'), test[1] ) def test_currency_byn(self): for test in TEST_CASES_TO_CURRENCY_BYN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BYN'), test[1] ) def test_currency_byr(self): for test in TEST_CASES_TO_CURRENCY_BYR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BYR'), test[1] ) def test_currency_bzd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='BZD'), test[1] ) def test_currency_cdf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CDF'), test[1] ) def test_currency_clp(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CLP'), test[1] ) def test_currency_cop(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='COP'), test[1] ) def test_currency_cup(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CUP'), test[1] ) def test_currency_cve(self): for test in TEST_CASES_TO_CURRENCY_CVE: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CVE'), test[1] ) def test_currency_cyp(self): for test in TEST_CASES_TO_CURRENCY_CYP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='CYP'), test[1] ) def test_currency_djf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='DJF'), test[1] ) def test_currency_dkk(self): for test in TEST_CASES_TO_CURRENCY_DKK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='DKK'), test[1] ) def test_currency_dop(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='DOP'), test[1] ) def test_currency_dzd(self): for test in TEST_CASES_TO_CURRENCY_DZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='DZD'), test[1] ) def test_currency_ecs(self): for test in TEST_CASES_TO_CURRENCY_ECS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ECS'), test[1] ) def test_currency_egp(self): for test in TEST_CASES_TO_CURRENCY_EGP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='EGP'), test[1] ) def test_currency_ern(self): for test in TEST_CASES_TO_CURRENCY_ERN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ERN'), test[1] ) def test_currency_etb(self): for test in TEST_CASES_TO_CURRENCY_ETB: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ETB'), test[1] ) def test_currency_fjd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='FJD'), test[1] ) def test_currency_fkp(self): for test in TEST_CASES_TO_CURRENCY_FKP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='FKP'), test[1] ) def test_currency_gel(self): for test in TEST_CASES_TO_CURRENCY_GEL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GEL'), test[1] ) def test_currency_ghs(self): for test in TEST_CASES_TO_CURRENCY_GHS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GHS'), test[1] ) def test_currency_gip(self): for test in TEST_CASES_TO_CURRENCY_FKP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GIP'), test[1] ) def test_currency_gmd(self): for test in TEST_CASES_TO_CURRENCY_GMD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GMD'), test[1] ) def test_currency_gnf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GNF'), test[1] ) def test_currency_gtq(self): for test in TEST_CASES_TO_CURRENCY_GTQ: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GTQ'), test[1] ) def test_currency_gyd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GYD'), test[1] ) def test_currency_hkd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='HKD'), test[1] ) def test_currency_hnl(self): for test in TEST_CASES_TO_CURRENCY_HNL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='HNL'), test[1] ) def test_currency_hrk(self): for test in TEST_CASES_TO_CURRENCY_HRK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='HRK'), test[1] ) def test_currency_htg(self): for test in TEST_CASES_TO_CURRENCY_HTG: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='HTG'), test[1] ) def test_currency_idr(self): for test in TEST_CASES_TO_CURRENCY_IDR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='IDR'), test[1] ) def test_currency_ils(self): for test in TEST_CASES_TO_CURRENCY_ILS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ILS'), test[1] ) def test_currency_iqd(self): for test in TEST_CASES_TO_CURRENCY_IQD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='IQD'), test[1] ) def test_currency_irr(self): for test in TEST_CASES_TO_CURRENCY_IRR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='IRR'), test[1] ) def test_currency_isk(self): for test in TEST_CASES_TO_CURRENCY_ISK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ISK'), test[1] ) def test_currency_itl(self): for test in TEST_CASES_TO_CURRENCY_ITL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ITL'), test[1] ) def test_currency_jmd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='JMD'), test[1] ) def test_currency_jod(self): for test in TEST_CASES_TO_CURRENCY_JOD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='JOD'), test[1] ) def test_currency_kes(self): for test in TEST_CASES_TO_CURRENCY_KES: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KES'), test[1] ) def test_currency_kgs(self): for test in TEST_CASES_TO_CURRENCY_KGS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KGS'), test[1] ) def test_currency_khr(self): for test in TEST_CASES_TO_CURRENCY_KHR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KHR'), test[1] ) def test_currency_kmf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KMF'), test[1] ) def test_currency_kwd(self): for test in TEST_CASES_TO_CURRENCY_KWD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KWD'), test[1] ) def test_currency_kyd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='KYD'), test[1] ) def test_currency_lak(self): for test in TEST_CASES_TO_CURRENCY_LAK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LAK'), test[1] ) def test_currency_lbp(self): for test in TEST_CASES_TO_CURRENCY_EGP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LBP'), test[1] ) def test_currency_lkr(self): for test in TEST_CASES_TO_CURRENCY_LKR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LKR'), test[1] ) def test_currency_lrd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LRD'), test[1] ) def test_currency_lsl(self): for test in TEST_CASES_TO_CURRENCY_LSL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LSL'), test[1] ) def test_currency_ltl(self): for test in TEST_CASES_TO_CURRENCY_LTL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LTL'), test[1] ) def test_currency_lvl(self): for test in TEST_CASES_TO_CURRENCY_LVL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LVL'), test[1] ) def test_currency_lyd(self): for test in TEST_CASES_TO_CURRENCY_LYD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='LYD'), test[1] ) def test_currency_mad(self): for test in TEST_CASES_TO_CURRENCY_MAD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MAD'), test[1] ) def test_currency_mdl(self): for test in TEST_CASES_TO_CURRENCY_MDL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MDL'), test[1] ) def test_currency_mga(self): for test in TEST_CASES_TO_CURRENCY_MGA: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MGA'), test[1] ) def test_currency_mkd(self): for test in TEST_CASES_TO_CURRENCY_MKD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MKD'), test[1] ) def test_currency_mmk(self): for test in TEST_CASES_TO_CURRENCY_MMK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MMK'), test[1] ) def test_currency_mnt(self): for test in TEST_CASES_TO_CURRENCY_MNT: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MNT'), test[1] ) def test_currency_mop(self): for test in TEST_CASES_TO_CURRENCY_MOP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MOP'), test[1] ) def test_currency_mro(self): for test in TEST_CASES_TO_CURRENCY_MRO: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MRO'), test[1] ) def test_currency_mru(self): for test in TEST_CASES_TO_CURRENCY_MRU: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MRU'), test[1] ) def test_currency_mur(self): for test in TEST_CASES_TO_CURRENCY_MUR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MUR'), test[1] ) def test_currency_mvr(self): for test in TEST_CASES_TO_CURRENCY_MVR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MVR'), test[1] ) def test_currency_mwk(self): for test in TEST_CASES_TO_CURRENCY_MWK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MWK'), test[1] ) def test_currency_myr(self): for test in TEST_CASES_TO_CURRENCY_MYR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MYR'), test[1] ) def test_currency_mzn(self): for test in TEST_CASES_TO_CURRENCY_MZN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='MZN'), test[1] ) def test_currency_nad(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='NAD'), test[1] ) def test_currency_ngn(self): for test in TEST_CASES_TO_CURRENCY_NGN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='NGN'), test[1] ) def test_currency_npr(self): for test in TEST_CASES_TO_CURRENCY_NPR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='NPR'), test[1] ) def test_currency_nzd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='NZD'), test[1] ) def test_currency_omr(self): for test in TEST_CASES_TO_CURRENCY_OMR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='OMR'), test[1] ) def test_currency_pab(self): for test in TEST_CASES_TO_CURRENCY_PAB: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PAB'), test[1] ) def test_currency_pgk(self): for test in TEST_CASES_TO_CURRENCY_PGK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PGK'), test[1] ) def test_currency_php(self): for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PHP'), test[1] ) def test_currency_pkr(self): for test in TEST_CASES_TO_CURRENCY_PKR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PKR'), test[1] ) def test_currency_plz(self): for test in TEST_CASES_TO_CURRENCY_PLZ: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PLZ'), test[1] ) def test_currency_pyg(self): for test in TEST_CASES_TO_CURRENCY_PYG: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='PYG'), test[1] ) def test_currency_qar(self): for test in TEST_CASES_TO_CURRENCY_QAR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='QAR'), test[1] ) def test_currency_qtq(self): for test in TEST_CASES_TO_CURRENCY_GTQ: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='GTQ'), test[1] ) def test_currency_rsd(self): for test in TEST_CASES_TO_CURRENCY_RSD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='RSD'), test[1] ) def test_currency_rur(self): for test in TEST_CASES_TO_CURRENCY_RUR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='RUR'), test[1] ) def test_currency_rwf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='RWF'), test[1] ) def test_currency_sar(self): for test in TEST_CASES_TO_CURRENCY_SAR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SAR'), test[1] ) def test_currency_sbd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SBD'), test[1] ) def test_currency_scr(self): for test in TEST_CASES_TO_CURRENCY_SCR: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SCR'), test[1] ) def test_currency_sdg(self): for test in TEST_CASES_TO_CURRENCY_EGP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SDG'), test[1] ) def test_currency_sgd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SGD'), test[1] ) def test_currency_shp(self): for test in TEST_CASES_TO_CURRENCY_SHP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SHP'), test[1] ) def test_currency_skk(self): for test in TEST_CASES_TO_CURRENCY_SKK: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SKK'), test[1] ) def test_currency_sll(self): for test in TEST_CASES_TO_CURRENCY_SLL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SLL'), test[1] ) def test_currency_srd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SRD'), test[1] ) def test_currency_ssp(self): for test in TEST_CASES_TO_CURRENCY_EGP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SSP'), test[1] ) def test_currency_std(self): for test in TEST_CASES_TO_CURRENCY_STD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='STD'), test[1] ) def test_currency_svc(self): for test in TEST_CASES_TO_CURRENCY_SVC: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SVC'), test[1] ) def test_currency_syp(self): for test in TEST_CASES_TO_CURRENCY_EGP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SYP'), test[1] ) def test_currency_szl(self): for test in TEST_CASES_TO_CURRENCY_SZL: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='SZL'), test[1] ) def test_currency_tjs(self): for test in TEST_CASES_TO_CURRENCY_TJS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TJS'), test[1] ) def test_currency_tmt(self): for test in TEST_CASES_TO_CURRENCY_TMT: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TMT'), test[1] ) def test_currency_tnd(self): for test in TEST_CASES_TO_CURRENCY_TND: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TND'), test[1] ) def test_currency_top(self): for test in TEST_CASES_TO_CURRENCY_TOP: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TOP'), test[1] ) def test_currency_ttd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TTD'), test[1] ) def test_currency_twd(self): for test in TEST_CASES_TO_CURRENCY_TWD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TWD'), test[1] ) def test_currency_tzs(self): for test in TEST_CASES_TO_CURRENCY_TZS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='TZS'), test[1] ) def test_currency_uag(self): for test in TEST_CASES_TO_CURRENCY_UAG: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='UAG'), test[1] ) def test_currency_ugx(self): for test in TEST_CASES_TO_CURRENCY_UGX: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='UGX'), test[1] ) def test_currency_uyu(self): for test in TEST_CASES_TO_CURRENCY_UYU: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='UYU'), test[1] ) def test_currency_uzs(self): for test in TEST_CASES_TO_CURRENCY_UZS: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='UZS'), test[1] ) def test_currency_vef(self): for test in TEST_CASES_TO_CURRENCY_VEF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='VEF'), test[1] ) def test_currency_vnd(self): for test in TEST_CASES_TO_CURRENCY_VND: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='VND'), test[1] ) def test_currency_vuv(self): for test in TEST_CASES_TO_CURRENCY_VUV: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='VUV'), test[1] ) def test_currency_wst(self): for test in TEST_CASES_TO_CURRENCY_WST: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='WST'), test[1] ) def test_currency_xaf(self): for test in TEST_CASES_TO_CURRENCY_XAF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='XAF'), test[1] ) def test_currency_xcd(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='XCD'), test[1] ) def test_currency_xof(self): for test in TEST_CASES_TO_CURRENCY_XAF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='XOF'), test[1] ) def test_currency_xpf(self): for test in TEST_CASES_TO_CURRENCY_XPF: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='XPF'), test[1] ) def test_currency_yer(self): for test in TEST_CASES_TO_CURRENCY_YER: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='YER'), test[1] ) def test_currency_yum(self): for test in TEST_CASES_TO_CURRENCY_YUM: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='YUM'), test[1] ) def test_currency_zmw(self): for test in TEST_CASES_TO_CURRENCY_ZMW: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ZMW'), test[1] ) def test_currency_zrz(self): for test in TEST_CASES_TO_CURRENCY_ZRZ: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ZRZ'), test[1] ) def test_currency_zwl(self): for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='es', to='currency', currency='ZWL'), test[1] ) num2words-0.5.14/tests/test_es_co.py000066400000000000000000000037621473005321200174110ustar00rootroot00000000000000# -*- 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 num2words import num2words from . import test_es TEST_CASES_TO_CURRENCY = ( (1, 'un peso'), (2, 'dos pesos'), (8, 'ocho pesos'), (12, 'doce pesos'), (21, 'veintiun pesos'), (81.25, 'ochenta y un pesos y veinticinco centavos'), (100, 'cien pesos'), ) class Num2WordsESCOTest(test_es.Num2WordsESTest): def test_number(self): for test in test_es.TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='es_CO'), test[1]) def test_ordinal(self): for test in test_es.TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='es_CO', ordinal=True), test[1] ) def test_ordinal_num(self): for test in test_es.TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='es', to='ordinal_num'), test[1] ) def test_currency(self): for test in TEST_CASES_TO_CURRENCY: self.assertEqual( num2words(test[0], lang='es_CO', to='currency'), test[1] ) num2words-0.5.14/tests/test_es_cr.py000066400000000000000000000041031473005321200174020ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2024, Randall Castro. 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 num2words import num2words from . import test_es TEST_CASES_TO_CURRENCY = ( (1, 'un colón'), (2, 'dos colónes'), (8, 'ocho colónes'), (12, 'doce colónes'), (21, 'veintiun colónes'), (81.25, 'ochenta y un colónes y veinticinco céntimos'), (100, 'cien colónes'), ) class Num2WordsESCOTest(test_es.Num2WordsESTest): def test_number(self): for test in test_es.TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='es_CR'), test[1]) def test_ordinal(self): for test in test_es.TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='es_CR', ordinal=True), test[1] ) def test_ordinal_num(self): for test in test_es.TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='es', to='ordinal_num'), test[1] ) def test_currency(self): for test in TEST_CASES_TO_CURRENCY: self.assertEqual( num2words(test[0], lang='es_CR', to='currency'), test[1] ) num2words-0.5.14/tests/test_es_gt.py000066400000000000000000000040201473005321200174060ustar00rootroot00000000000000# -*- 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 num2words import num2words from . import test_es TEST_CASES_TO_CURRENCY = ( (1, 'un quetzal'), (2, 'dos quetzales'), (8, 'ocho quetzales'), (12, 'doce quetzales'), (21, 'veintiun quetzales'), (81.25, 'ochenta y un quetzales y veinticinco centavos'), (100, 'cien quetzales'), ) class Num2WordsESGTTest(test_es.Num2WordsESTest): def test_number(self): for test in test_es.TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='es_GT'), test[1]) def test_ordinal(self): for test in test_es.TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='es_GT', ordinal=True), test[1] ) def test_ordinal_num(self): for test in test_es.TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='es_GT', to='ordinal_num'), test[1] ) def test_currency(self): for test in TEST_CASES_TO_CURRENCY: self.assertEqual( num2words(test[0], lang='es_GT', to='currency'), test[1] ) num2words-0.5.14/tests/test_es_ni.py000066400000000000000000000030551473005321200174110ustar00rootroot00000000000000# -*- 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 num2words import num2words from . import test_es TEST_NIO = ( (1.0, 'un córdoba con cero centavos'), (2.0, 'dos córdobas con cero centavos'), (8.0, 'ocho córdobas con cero centavos'), (12.0, 'doce córdobas con cero centavos'), (21.0, 'veintiun córdobas con cero centavos'), (81.25, 'ochenta y un córdobas con veinticinco centavos'), (100.00, 'cien córdobas con cero centavos'), ) class Num2WordsESNITest(test_es.Num2WordsESTest): def test_currency(self): for test in TEST_NIO: self.assertEqual( num2words(test[0], lang='es_NI', to='currency'), test[1] ) num2words-0.5.14/tests/test_es_ve.py000066400000000000000000000040351473005321200174140ustar00rootroot00000000000000# -*- 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 num2words import num2words from . import test_es TEST_CASES_TO_CURRENCY = ( (1, 'un bolívar'), (2, 'dos bolívares'), (8, 'ocho bolívares'), (12, 'doce bolívares'), (21, 'veintiun bolívares'), (81.25, 'ochenta y un bolívares y veinticinco centavos'), (100, 'cien bolívares'), ) class Num2WordsESVETest(test_es.Num2WordsESTest): def test_number(self): for test in test_es.TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='es_VE'), test[1]) def test_ordinal(self): for test in test_es.TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='es_VE', ordinal=True), test[1] ) def test_ordinal_num(self): for test in test_es.TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='es', to='ordinal_num'), test[1] ) def test_currency(self): for test in TEST_CASES_TO_CURRENCY: self.assertEqual( num2words(test[0], lang='es_VE', to='currency', old=True), test[1] ) num2words-0.5.14/tests/test_fa.py000066400000000000000000000113071473005321200167010ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2003, Taro Ogawa. All Rights Reserved. # Copyright (c) 2013, Savoir-faire Linux inc. All Rights Reserved. # Copyright (c) 2020, Hamidreza Kalbasi. 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 unittest import TestCase from num2words import num2words class Num2WordsFATest(TestCase): def test_and_join_199(self): self.assertEqual(num2words(199, lang='fa'), "صد و نود و نه") def test_ordinal(self): self.assertEqual( num2words(0, lang='fa', to='ordinal'), 'صفرم' ) self.assertEqual( num2words(1, lang='fa', to='ordinal'), 'یکم' ) self.assertEqual( num2words(13, lang='fa', to='ordinal'), 'سیزدهم' ) self.assertEqual( num2words(23, lang='fa', to='ordinal'), 'بیست و سوم' ) self.assertEqual( num2words(12, lang='fa', to='ordinal'), 'دوازدهم' ) self.assertEqual( num2words(113, lang='fa', to='ordinal'), 'صد و سیزدهم' ) self.assertEqual( num2words(103, lang='fa', to='ordinal'), 'صد و سوم' ) def test_cardinal(self): self.assertEqual(num2words(130000, lang='fa'), "صد و سی هزار") self.assertEqual(num2words(242, lang='fa'), "دویست و چهل و دو") self.assertEqual(num2words(800, lang='fa'), "هشتصد") self.assertEqual(num2words(-203, lang='fa'), "منفی دویست و سه") self.assertEqual( num2words(1234567890, lang='fa'), "یک میلیارد و دویست و سی و چهار میلیون و" " پانصد و شصت و هفت هزار و هشتصد و نود" ) def test_year(self): self.assertEqual(num2words(1398, lang='fa', to='year'), "هزار و سیصد و نود و هشت") self.assertEqual(num2words(1399, lang='fa', to='year'), "هزار و سیصد و نود و نه") self.assertEqual( num2words(1400, lang='fa', to='year'), "هزار و چهارصد") def test_currency(self): self.assertEqual( num2words(1000, lang='fa', to='currency'), 'هزار تومان') self.assertEqual( num2words(1500000, lang='fa', to='currency'), 'یک میلیون و پانصد هزار تومان' ) def test_ordinal_num(self): self.assertEqual(num2words(10, lang='fa', to='ordinal_num'), '10م') self.assertEqual(num2words(21, lang='fa', to='ordinal_num'), '21م') self.assertEqual(num2words(102, lang='fa', to='ordinal_num'), '102م') self.assertEqual(num2words(73, lang='fa', to='ordinal_num'), '73م') def test_cardinal_for_float_number(self): self.assertEqual(num2words(12.5, lang='fa'), "دوازده و نیم") self.assertEqual(num2words(0.75, lang='fa'), "هفتاد و پنج صدم") self.assertEqual(num2words(12.51, lang='fa'), "دوازده و پنجاه و یک صدم") self.assertEqual(num2words(12.53, lang='fa'), "دوازده و پنجاه و سه صدم") self.assertEqual(num2words(12.59, lang='fa'), "دوازده و پنجاه و نه صدم") self.assertEqual(num2words(0.000001, lang='fa'), "یک میلیونیم") def test_overflow(self): with self.assertRaises(OverflowError): num2words("1000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000") num2words-0.5.14/tests/test_fi.py000066400000000000000000003655501473005321200167250ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words CASES = ["nominative", "genitive", "partitive", # grammatical "inessive", "elative", "illative", # internal locative "adessive", "ablative", "allative", # external locative "essive", "translative", # essive "instructive", "abessive", "comitative"] # rare def n2f(*args, **kwargs): return num2words(lang='fi', *args, **kwargs) class Num2WordsFITest(TestCase): def test_low(self): # zero self.assertEqual( tuple(n2f(0, to="cardinal", case=c) for c in CASES), ("nolla", "nollan", "nollaa", "nollassa", "nollasta", "nollaan", "nollalla", "nollalta", "nollalle", "nollana", "nollaksi", "nollin", "nollatta", "nolline") ) self.assertEqual( tuple(n2f(0, to="cardinal", case=c, plural=True) for c in CASES), ("nollat", "nollien", "nollia", "nollissa", "nollista", "nolliin", "nollilla", "nollilta", "nollille", "nollina", "nolliksi", "nollin", "nollitta", "nolline") ) # one self.assertEqual( tuple(n2f(1, to="cardinal", case=c) for c in CASES), ("yksi", "yhden", "yhtä", "yhdessä", "yhdestä", "yhteen", "yhdellä", "yhdeltä", "yhdelle", "yhtenä", "yhdeksi", "yksin", "yhdettä", "yksine") ) self.assertEqual( tuple(n2f(1, to="cardinal", case=c, plural=True) for c in CASES), ("yhdet", "yksien", "yksiä", "yksissä", "yksistä", "yksiin", "yksillä", "yksiltä", "yksille", "yksinä", "yksiksi", "yksin", "yksittä", "yksine") ) # two self.assertEqual( tuple(n2f(2, to="cardinal", case=c) for c in CASES), ("kaksi", "kahden", "kahta", "kahdessa", "kahdesta", "kahteen", "kahdella", "kahdelta", "kahdelle", "kahtena", "kahdeksi", "kaksin", "kahdetta", "kaksine") ) self.assertEqual( tuple(n2f(2, to="cardinal", case=c, plural=True) for c in CASES), ("kahdet", "kaksien", "kaksia", "kaksissa", "kaksista", "kaksiin", "kaksilla", "kaksilta", "kaksille", "kaksina", "kaksiksi", "kaksin", "kaksitta", "kaksine") ) # three self.assertEqual( tuple(n2f(3, to="cardinal", case=c) for c in CASES), ("kolme", "kolmen", "kolmea", "kolmessa", "kolmesta", "kolmeen", "kolmella", "kolmelta", "kolmelle", "kolmena", "kolmeksi", "kolmen", "kolmetta", "kolmine") ) self.assertEqual( tuple(n2f(3, to="cardinal", case=c, plural=True) for c in CASES), ("kolmet", "kolmien", "kolmia", "kolmissa", "kolmista", "kolmiin", "kolmilla", "kolmilta", "kolmille", "kolmina", "kolmiksi", "kolmin", "kolmitta", "kolmine") ) # four self.assertEqual( tuple(n2f(4, to="cardinal", case=c) for c in CASES), ("neljä", "neljän", "neljää", "neljässä", "neljästä", "neljään", "neljällä", "neljältä", "neljälle", "neljänä", "neljäksi", "neljin", "neljättä", "neljine") ) self.assertEqual( tuple(n2f(4, to="cardinal", case=c, plural=True) for c in CASES), ("neljät", "neljien", "neljiä", "neljissä", "neljistä", "neljiin", "neljillä", "neljiltä", "neljille", "neljinä", "neljiksi", "neljin", "neljittä", "neljine") ) # five self.assertEqual( tuple(n2f(5, to="cardinal", case=c) for c in CASES), ("viisi", "viiden", "viittä", "viidessä", "viidestä", "viiteen", "viidellä", "viideltä", "viidelle", "viitenä", "viideksi", "viisin", "viidettä", "viisine") ) self.assertEqual( tuple(n2f(5, to="cardinal", case=c, plural=True) for c in CASES), ("viidet", "viisien", "viisiä", "viisissä", "viisistä", "viisiin", "viisillä", "viisiltä", "viisille", "viisinä", "viisiksi", "viisin", "viisittä", "viisine") ) # six self.assertEqual( tuple(n2f(6, to="cardinal", case=c) for c in CASES), ("kuusi", "kuuden", "kuutta", "kuudessa", "kuudesta", "kuuteen", "kuudella", "kuudelta", "kuudelle", "kuutena", "kuudeksi", "kuusin", "kuudetta", "kuusine") ) self.assertEqual( tuple(n2f(6, to="cardinal", case=c, plural=True) for c in CASES), ("kuudet", "kuusien", "kuusia", "kuusissa", "kuusista", "kuusiin", "kuusilla", "kuusilta", "kuusille", "kuusina", "kuusiksi", "kuusin", "kuusitta", "kuusine") ) # seven self.assertEqual( tuple(n2f(7, to="cardinal", case=c) for c in CASES), ("seitsemän", "seitsemän", "seitsemää", "seitsemässä", "seitsemästä", "seitsemään", "seitsemällä", "seitsemältä", "seitsemälle", "seitsemänä", "seitsemäksi", "seitsemin", "seitsemättä", "seitsemine") ) self.assertEqual( tuple(n2f(7, to="cardinal", case=c, plural=True) for c in CASES), ("seitsemät", "seitsemien", "seitsemiä", "seitsemissä", "seitsemistä", "seitsemiin", "seitsemillä", "seitsemiltä", "seitsemille", "seitseminä", "seitsemiksi", "seitsemin", "seitsemittä", "seitsemine") ) # eight self.assertEqual( tuple(n2f(8, to="cardinal", case=c) for c in CASES), ("kahdeksan", "kahdeksan", "kahdeksaa", "kahdeksassa", "kahdeksasta", "kahdeksaan", "kahdeksalla", "kahdeksalta", "kahdeksalle", "kahdeksana", "kahdeksaksi", "kahdeksin", "kahdeksatta", "kahdeksine") ) self.assertEqual( tuple(n2f(8, to="cardinal", case=c, plural=True) for c in CASES), ("kahdeksat", "kahdeksien", "kahdeksia", "kahdeksissa", "kahdeksista", "kahdeksiin", "kahdeksilla", "kahdeksilta", "kahdeksille", "kahdeksina", "kahdeksiksi", "kahdeksin", "kahdeksitta", "kahdeksine") ) self.assertEqual( n2f(8, to="cardinal", case="genitive", plural=True, prefer=["ain"]), "kahdeksain" ) # nine self.assertEqual( tuple(n2f(9, to="cardinal", case=c) for c in CASES), ("yhdeksän", "yhdeksän", "yhdeksää", "yhdeksässä", "yhdeksästä", "yhdeksään", "yhdeksällä", "yhdeksältä", "yhdeksälle", "yhdeksänä", "yhdeksäksi", "yhdeksin", "yhdeksättä", "yhdeksine") ) self.assertEqual( tuple(n2f(9, to="cardinal", case=c, plural=True) for c in CASES), ("yhdeksät", "yhdeksien", "yhdeksiä", "yhdeksissä", "yhdeksistä", "yhdeksiin", "yhdeksillä", "yhdeksiltä", "yhdeksille", "yhdeksinä", "yhdeksiksi", "yhdeksin", "yhdeksittä", "yhdeksine") ) # ten self.assertEqual( tuple(n2f(10, to="cardinal", case=c) for c in CASES), ("kymmenen", "kymmenen", "kymmentä", "kymmenessä", "kymmenestä", "kymmeneen", "kymmenellä", "kymmeneltä", "kymmenelle", "kymmenenä", "kymmeneksi", "kymmenin", "kymmenettä", "kymmenine") ) self.assertEqual( tuple(n2f(10, to="cardinal", case=c, plural=True) for c in CASES), ("kymmenet", "kymmenien", "kymmeniä", "kymmenissä", "kymmenistä", "kymmeniin", "kymmenillä", "kymmeniltä", "kymmenille", "kymmeninä", "kymmeniksi", "kymmenin", "kymmenittä", "kymmenine") ) # eleven self.assertEqual( tuple(n2f(11, to="cardinal", case=c) for c in CASES), ("yksitoista", "yhdentoista", "yhtätoista", "yhdessätoista", "yhdestätoista", "yhteentoista", "yhdellätoista", "yhdeltätoista", "yhdelletoista", "yhtenätoista", "yhdeksitoista", "yksintoista", "yhdettätoista", "yksinetoista") ) self.assertEqual( tuple(n2f(11, to="cardinal", case=c, plural=True) for c in CASES), ("yhdettoista", "yksientoista", "yksiätoista", "yksissätoista", "yksistätoista", "yksiintoista", "yksillätoista", "yksiltätoista", "yksilletoista", "yksinätoista", "yksiksitoista", "yksintoista", "yksittätoista", "yksinetoista") ) # twelve self.assertEqual( tuple(n2f(12, to="cardinal", case=c) for c in CASES), ("kaksitoista", "kahdentoista", "kahtatoista", "kahdessatoista", "kahdestatoista", "kahteentoista", "kahdellatoista", "kahdeltatoista", "kahdelletoista", "kahtenatoista", "kahdeksitoista", "kaksintoista", "kahdettatoista", "kaksinetoista") ) self.assertEqual( tuple(n2f(12, to="cardinal", case=c, plural=True) for c in CASES), ("kahdettoista", "kaksientoista", "kaksiatoista", "kaksissatoista", "kaksistatoista", "kaksiintoista", "kaksillatoista", "kaksiltatoista", "kaksilletoista", "kaksinatoista", "kaksiksitoista", "kaksintoista", "kaksittatoista", "kaksinetoista") ) # thirteen self.assertEqual( tuple(n2f(13, to="cardinal", case=c) for c in CASES), ("kolmetoista", "kolmentoista", "kolmeatoista", "kolmessatoista", "kolmestatoista", "kolmeentoista", "kolmellatoista", "kolmeltatoista", "kolmelletoista", "kolmenatoista", "kolmeksitoista", "kolmentoista", "kolmettatoista", "kolminetoista") ) self.assertEqual( tuple(n2f(13, to="cardinal", case=c, plural=True) for c in CASES), ("kolmettoista", "kolmientoista", "kolmiatoista", "kolmissatoista", "kolmistatoista", "kolmiintoista", "kolmillatoista", "kolmiltatoista", "kolmilletoista", "kolminatoista", "kolmiksitoista", "kolmintoista", "kolmittatoista", "kolminetoista") ) # fourteen self.assertEqual( tuple(n2f(14, to="cardinal", case=c) for c in CASES), ("neljätoista", "neljäntoista", "neljäätoista", "neljässätoista", "neljästätoista", "neljääntoista", "neljällätoista", "neljältätoista", "neljälletoista", "neljänätoista", "neljäksitoista", "neljintoista", "neljättätoista", "neljinetoista") ) self.assertEqual( tuple(n2f(14, to="cardinal", case=c, plural=True) for c in CASES), ("neljättoista", "neljientoista", "neljiätoista", "neljissätoista", "neljistätoista", "neljiintoista", "neljillätoista", "neljiltätoista", "neljilletoista", "neljinätoista", "neljiksitoista", "neljintoista", "neljittätoista", "neljinetoista") ) # fifteen self.assertEqual( tuple(n2f(15, to="cardinal", case=c) for c in CASES), ("viisitoista", "viidentoista", "viittätoista", "viidessätoista", "viidestätoista", "viiteentoista", "viidellätoista", "viideltätoista", "viidelletoista", "viitenätoista", "viideksitoista", "viisintoista", "viidettätoista", "viisinetoista") ) self.assertEqual( tuple(n2f(15, to="cardinal", case=c, plural=True) for c in CASES), ("viidettoista", "viisientoista", "viisiätoista", "viisissätoista", "viisistätoista", "viisiintoista", "viisillätoista", "viisiltätoista", "viisilletoista", "viisinätoista", "viisiksitoista", "viisintoista", "viisittätoista", "viisinetoista") ) # sixteen self.assertEqual( tuple(n2f(16, to="cardinal", case=c) for c in CASES), ("kuusitoista", "kuudentoista", "kuuttatoista", "kuudessatoista", "kuudestatoista", "kuuteentoista", "kuudellatoista", "kuudeltatoista", "kuudelletoista", "kuutenatoista", "kuudeksitoista", "kuusintoista", "kuudettatoista", "kuusinetoista") ) self.assertEqual( tuple(n2f(16, to="cardinal", case=c, plural=True) for c in CASES), ("kuudettoista", "kuusientoista", "kuusiatoista", "kuusissatoista", "kuusistatoista", "kuusiintoista", "kuusillatoista", "kuusiltatoista", "kuusilletoista", "kuusinatoista", "kuusiksitoista", "kuusintoista", "kuusittatoista", "kuusinetoista") ) # seventeen self.assertEqual( tuple(n2f(17, to="cardinal", case=c) for c in CASES), ("seitsemäntoista", "seitsemäntoista", "seitsemäätoista", "seitsemässätoista", "seitsemästätoista", "seitsemääntoista", "seitsemällätoista", "seitsemältätoista", "seitsemälletoista", "seitsemänätoista", "seitsemäksitoista", "seitsemintoista", "seitsemättätoista", "seitseminetoista") ) self.assertEqual( tuple(n2f(17, to="cardinal", case=c, plural=True) for c in CASES), ("seitsemättoista", "seitsemientoista", "seitsemiätoista", "seitsemissätoista", "seitsemistätoista", "seitsemiintoista", "seitsemillätoista", "seitsemiltätoista", "seitsemilletoista", "seitseminätoista", "seitsemiksitoista", "seitsemintoista", "seitsemittätoista", "seitseminetoista") ) # eighteen self.assertEqual( tuple(n2f(18, to="cardinal", case=c) for c in CASES), ("kahdeksantoista", "kahdeksantoista", "kahdeksaatoista", "kahdeksassatoista", "kahdeksastatoista", "kahdeksaantoista", "kahdeksallatoista", "kahdeksaltatoista", "kahdeksalletoista", "kahdeksanatoista", "kahdeksaksitoista", "kahdeksintoista", "kahdeksattatoista", "kahdeksinetoista") ) self.assertEqual( tuple(n2f(18, to="cardinal", case=c, plural=True) for c in CASES), ("kahdeksattoista", "kahdeksientoista", "kahdeksiatoista", "kahdeksissatoista", "kahdeksistatoista", "kahdeksiintoista", "kahdeksillatoista", "kahdeksiltatoista", "kahdeksilletoista", "kahdeksinatoista", "kahdeksiksitoista", "kahdeksintoista", "kahdeksittatoista", "kahdeksinetoista") ) # nineteen self.assertEqual( tuple(n2f(19, to="cardinal", case=c) for c in CASES), ("yhdeksäntoista", "yhdeksäntoista", "yhdeksäätoista", "yhdeksässätoista", "yhdeksästätoista", "yhdeksääntoista", "yhdeksällätoista", "yhdeksältätoista", "yhdeksälletoista", "yhdeksänätoista", "yhdeksäksitoista", "yhdeksintoista", "yhdeksättätoista", "yhdeksinetoista") ) self.assertEqual( tuple(n2f(19, to="cardinal", case=c, plural=True) for c in CASES), ("yhdeksättoista", "yhdeksientoista", "yhdeksiätoista", "yhdeksissätoista", "yhdeksistätoista", "yhdeksiintoista", "yhdeksillätoista", "yhdeksiltätoista", "yhdeksilletoista", "yhdeksinätoista", "yhdeksiksitoista", "yhdeksintoista", "yhdeksittätoista", "yhdeksinetoista") ) # twenty self.assertEqual( tuple(n2f(20, to="cardinal", case=c) for c in CASES), ("kaksikymmentä", "kahdenkymmenen", "kahtakymmentä", "kahdessakymmenessä", "kahdestakymmenestä", "kahteenkymmeneen", "kahdellakymmenellä", "kahdeltakymmeneltä", "kahdellekymmenelle", "kahtenakymmenenä", "kahdeksikymmeneksi", "kaksinkymmenin", "kahdettakymmenettä", "kaksinekymmenine") ) self.assertEqual( tuple(n2f(20, to="cardinal", case=c, plural=True) for c in CASES), ("kahdetkymmenet", "kaksienkymmenien", "kaksiakymmeniä", "kaksissakymmenissä", "kaksistakymmenistä", "kaksiinkymmeniin", "kaksillakymmenillä", "kaksiltakymmeniltä", "kaksillekymmenille", "kaksinakymmeninä", "kaksiksikymmeniksi", "kaksinkymmenin", "kaksittakymmenittä", "kaksinekymmenine") ) def test_low_ord(self): # minus one with self.assertRaises(TypeError): n2f(-1, to="ordinal") # zero self.assertEqual( tuple(n2f(0, to="ordinal", case=c) for c in CASES), ("nollas", "nollannen", "nollatta", "nollannessa", "nollannesta", "nollanteen", "nollannella", "nollannelta", "nollannelle", "nollantena", "nollanneksi", "nollansin", "nollannetta", "nollansine") ) self.assertEqual( tuple(n2f(0, to="ordinal", case=c, plural=True) for c in CASES), ("nollannet", "nollansien", "nollansia", "nollansissa", "nollansista", "nollansiin", "nollansilla", "nollansilta", "nollansille", "nollansina", "nollansiksi", "nollansin", "nollansitta", "nollansine") ) # one self.assertEqual( tuple(n2f(1, to="ordinal", case=c) for c in CASES), ("ensimmäinen", "ensimmäisen", "ensimmäistä", "ensimmäisessä", "ensimmäisestä", "ensimmäiseen", "ensimmäisellä", "ensimmäiseltä", "ensimmäiselle", "ensimmäisenä", "ensimmäiseksi", "ensimmäisin", "ensimmäisettä", "ensimmäisine") ) self.assertEqual( tuple(n2f(1, to="ordinal", case=c, plural=True) for c in CASES), ("ensimmäiset", "ensimmäisten", "ensimmäisiä", "ensimmäisissä", "ensimmäisistä", "ensimmäisiin", "ensimmäisillä", "ensimmäisiltä", "ensimmäisille", "ensimmäisinä", "ensimmäisiksi", "ensimmäisin", "ensimmäisittä", "ensimmäisine") ) # two self.assertEqual( tuple(n2f(2, to="ordinal", case=c) for c in CASES), ("toinen", "toisen", "toista", "toisessa", "toisesta", "toiseen", "toisella", "toiselta", "toiselle", "toisena", "toiseksi", "toisin", "toisetta", "toisine") ) self.assertEqual( tuple(n2f(2, to="ordinal", case=c, plural=True) for c in CASES), ("toiset", "toisten", "toisia", "toisissa", "toisista", "toisiin", "toisilla", "toisilta", "toisille", "toisina", "toisiksi", "toisin", "toisitta", "toisine") ) # three self.assertEqual( tuple(n2f(3, to="ordinal", case=c) for c in CASES), ("kolmas", "kolmannen", "kolmatta", "kolmannessa", "kolmannesta", "kolmanteen", "kolmannella", "kolmannelta", "kolmannelle", "kolmantena", "kolmanneksi", "kolmansin", "kolmannetta", "kolmansine") ) self.assertEqual( tuple(n2f(3, to="ordinal", case=c, plural=True) for c in CASES), ("kolmannet", "kolmansien", "kolmansia", "kolmansissa", "kolmansista", "kolmansiin", "kolmansilla", "kolmansilta", "kolmansille", "kolmansina", "kolmansiksi", "kolmansin", "kolmansitta", "kolmansine") ) # four self.assertEqual( tuple(n2f(4, to="ordinal", case=c) for c in CASES), ("neljäs", "neljännen", "neljättä", "neljännessä", "neljännestä", "neljänteen", "neljännellä", "neljänneltä", "neljännelle", "neljäntenä", "neljänneksi", "neljänsin", "neljännettä", "neljänsine") ) self.assertEqual( tuple(n2f(4, to="ordinal", case=c, plural=True) for c in CASES), ("neljännet", "neljänsien", "neljänsiä", "neljänsissä", "neljänsistä", "neljänsiin", "neljänsillä", "neljänsiltä", "neljänsille", "neljänsinä", "neljänsiksi", "neljänsin", "neljänsittä", "neljänsine") ) # five self.assertEqual( tuple(n2f(5, to="ordinal", case=c) for c in CASES), ("viides", "viidennen", "viidettä", "viidennessä", "viidennestä", "viidenteen", "viidennellä", "viidenneltä", "viidennelle", "viidentenä", "viidenneksi", "viidensin", "viidennettä", "viidensine") ) self.assertEqual( tuple(n2f(5, to="ordinal", case=c, plural=True) for c in CASES), ("viidennet", "viidensien", "viidensiä", "viidensissä", "viidensistä", "viidensiin", "viidensillä", "viidensiltä", "viidensille", "viidensinä", "viidensiksi", "viidensin", "viidensittä", "viidensine") ) # six self.assertEqual( tuple(n2f(6, to="ordinal", case=c) for c in CASES), ("kuudes", "kuudennen", "kuudetta", "kuudennessa", "kuudennesta", "kuudenteen", "kuudennella", "kuudennelta", "kuudennelle", "kuudentena", "kuudenneksi", "kuudensin", "kuudennetta", "kuudensine") ) self.assertEqual( tuple(n2f(6, to="ordinal", case=c, plural=True) for c in CASES), ("kuudennet", "kuudensien", "kuudensia", "kuudensissa", "kuudensista", "kuudensiin", "kuudensilla", "kuudensilta", "kuudensille", "kuudensina", "kuudensiksi", "kuudensin", "kuudensitta", "kuudensine") ) # seven self.assertEqual( tuple(n2f(7, to="ordinal", case=c) for c in CASES), ("seitsemäs", "seitsemännen", "seitsemättä", "seitsemännessä", "seitsemännestä", "seitsemänteen", "seitsemännellä", "seitsemänneltä", "seitsemännelle", "seitsemäntenä", "seitsemänneksi", "seitsemänsin", "seitsemännettä", "seitsemänsine") ) self.assertEqual( tuple(n2f(7, to="ordinal", case=c, plural=True) for c in CASES), ("seitsemännet", "seitsemänsien", "seitsemänsiä", "seitsemänsissä", "seitsemänsistä", "seitsemänsiin", "seitsemänsillä", "seitsemänsiltä", "seitsemänsille", "seitsemänsinä", "seitsemänsiksi", "seitsemänsin", "seitsemänsittä", "seitsemänsine") ) # eight self.assertEqual( tuple(n2f(8, to="ordinal", case=c) for c in CASES), ("kahdeksas", "kahdeksannen", "kahdeksatta", "kahdeksannessa", "kahdeksannesta", "kahdeksanteen", "kahdeksannella", "kahdeksannelta", "kahdeksannelle", "kahdeksantena", "kahdeksanneksi", "kahdeksansin", "kahdeksannetta", "kahdeksansine") ) self.assertEqual( tuple(n2f(8, to="ordinal", case=c, plural=True) for c in CASES), ("kahdeksannet", "kahdeksansien", "kahdeksansia", "kahdeksansissa", "kahdeksansista", "kahdeksansiin", "kahdeksansilla", "kahdeksansilta", "kahdeksansille", "kahdeksansina", "kahdeksansiksi", "kahdeksansin", "kahdeksansitta", "kahdeksansine") ) # nine self.assertEqual( tuple(n2f(9, to="ordinal", case=c) for c in CASES), ("yhdeksäs", "yhdeksännen", "yhdeksättä", "yhdeksännessä", "yhdeksännestä", "yhdeksänteen", "yhdeksännellä", "yhdeksänneltä", "yhdeksännelle", "yhdeksäntenä", "yhdeksänneksi", "yhdeksänsin", "yhdeksännettä", "yhdeksänsine") ) self.assertEqual( tuple(n2f(9, to="ordinal", case=c, plural=True) for c in CASES), ("yhdeksännet", "yhdeksänsien", "yhdeksänsiä", "yhdeksänsissä", "yhdeksänsistä", "yhdeksänsiin", "yhdeksänsillä", "yhdeksänsiltä", "yhdeksänsille", "yhdeksänsinä", "yhdeksänsiksi", "yhdeksänsin", "yhdeksänsittä", "yhdeksänsine") ) # ten self.assertEqual( tuple(n2f(10, to="ordinal", case=c) for c in CASES), ("kymmenes", "kymmenennen", "kymmenettä", "kymmenennessä", "kymmenennestä", "kymmenenteen", "kymmenennellä", "kymmenenneltä", "kymmenennelle", "kymmenentenä", "kymmenenneksi", "kymmenensin", "kymmenennettä", "kymmenensine") ) self.assertEqual( tuple(n2f(10, to="ordinal", case=c, plural=True) for c in CASES), ("kymmenennet", "kymmenensien", "kymmenensiä", "kymmenensissä", "kymmenensistä", "kymmenensiin", "kymmenensillä", "kymmenensiltä", "kymmenensille", "kymmenensinä", "kymmenensiksi", "kymmenensin", "kymmenensittä", "kymmenensine") ) # eleven self.assertEqual( tuple(n2f(11, to="ordinal", case=c) for c in CASES), ("yhdestoista", "yhdennentoista", "yhdettätoista", "yhdennessätoista", "yhdennestätoista", "yhdenteentoista", "yhdennellätoista", "yhdenneltätoista", "yhdennelletoista", "yhdentenätoista", "yhdenneksitoista", "yhdensintoista", "yhdennettätoista", "yhdensinetoista") ) self.assertEqual( tuple(n2f(11, to="ordinal", case=c, plural=True) for c in CASES), ("yhdennettoista", "yhdensientoista", "yhdensiätoista", "yhdensissätoista", "yhdensistätoista", "yhdensiintoista", "yhdensillätoista", "yhdensiltätoista", "yhdensilletoista", "yhdensinätoista", "yhdensiksitoista", "yhdensintoista", "yhdensittätoista", "yhdensinetoista") ) # twelve self.assertEqual( tuple(n2f(12, to="ordinal", case=c) for c in CASES), ("kahdestoista", "kahdennentoista", "kahdettatoista", "kahdennessatoista", "kahdennestatoista", "kahdenteentoista", "kahdennellatoista", "kahdenneltatoista", "kahdennelletoista", "kahdentenatoista", "kahdenneksitoista", "kahdensintoista", "kahdennettatoista", "kahdensinetoista") ) self.assertEqual( tuple(n2f(12, to="ordinal", case=c, plural=True) for c in CASES), ("kahdennettoista", "kahdensientoista", "kahdensiatoista", "kahdensissatoista", "kahdensistatoista", "kahdensiintoista", "kahdensillatoista", "kahdensiltatoista", "kahdensilletoista", "kahdensinatoista", "kahdensiksitoista", "kahdensintoista", "kahdensittatoista", "kahdensinetoista") ) # thirteen self.assertEqual( tuple(n2f(13, to="ordinal", case=c) for c in CASES), ("kolmastoista", "kolmannentoista", "kolmattatoista", "kolmannessatoista", "kolmannestatoista", "kolmanteentoista", "kolmannellatoista", "kolmanneltatoista", "kolmannelletoista", "kolmantenatoista", "kolmanneksitoista", "kolmansintoista", "kolmannettatoista", "kolmansinetoista") ) self.assertEqual( tuple(n2f(13, to="ordinal", case=c, plural=True) for c in CASES), ("kolmannettoista", "kolmansientoista", "kolmansiatoista", "kolmansissatoista", "kolmansistatoista", "kolmansiintoista", "kolmansillatoista", "kolmansiltatoista", "kolmansilletoista", "kolmansinatoista", "kolmansiksitoista", "kolmansintoista", "kolmansittatoista", "kolmansinetoista") ) # fourteen self.assertEqual( tuple(n2f(14, to="ordinal", case=c) for c in CASES), ("neljästoista", "neljännentoista", "neljättätoista", "neljännessätoista", "neljännestätoista", "neljänteentoista", "neljännellätoista", "neljänneltätoista", "neljännelletoista", "neljäntenätoista", "neljänneksitoista", "neljänsintoista", "neljännettätoista", "neljänsinetoista") ) self.assertEqual( tuple(n2f(14, to="ordinal", case=c, plural=True) for c in CASES), ("neljännettoista", "neljänsientoista", "neljänsiätoista", "neljänsissätoista", "neljänsistätoista", "neljänsiintoista", "neljänsillätoista", "neljänsiltätoista", "neljänsilletoista", "neljänsinätoista", "neljänsiksitoista", "neljänsintoista", "neljänsittätoista", "neljänsinetoista") ) # fifteen self.assertEqual( tuple(n2f(15, to="ordinal", case=c) for c in CASES), ("viidestoista", "viidennentoista", "viidettätoista", "viidennessätoista", "viidennestätoista", "viidenteentoista", "viidennellätoista", "viidenneltätoista", "viidennelletoista", "viidentenätoista", "viidenneksitoista", "viidensintoista", "viidennettätoista", "viidensinetoista") ) self.assertEqual( tuple(n2f(15, to="ordinal", case=c, plural=True) for c in CASES), ("viidennettoista", "viidensientoista", "viidensiätoista", "viidensissätoista", "viidensistätoista", "viidensiintoista", "viidensillätoista", "viidensiltätoista", "viidensilletoista", "viidensinätoista", "viidensiksitoista", "viidensintoista", "viidensittätoista", "viidensinetoista") ) # sixteen self.assertEqual( tuple(n2f(16, to="ordinal", case=c) for c in CASES), ("kuudestoista", "kuudennentoista", "kuudettatoista", "kuudennessatoista", "kuudennestatoista", "kuudenteentoista", "kuudennellatoista", "kuudenneltatoista", "kuudennelletoista", "kuudentenatoista", "kuudenneksitoista", "kuudensintoista", "kuudennettatoista", "kuudensinetoista") ) self.assertEqual( tuple(n2f(16, to="ordinal", case=c, plural=True) for c in CASES), ("kuudennettoista", "kuudensientoista", "kuudensiatoista", "kuudensissatoista", "kuudensistatoista", "kuudensiintoista", "kuudensillatoista", "kuudensiltatoista", "kuudensilletoista", "kuudensinatoista", "kuudensiksitoista", "kuudensintoista", "kuudensittatoista", "kuudensinetoista") ) # seventeen self.assertEqual( tuple(n2f(17, to="ordinal", case=c) for c in CASES), ( "seitsemästoista", "seitsemännentoista", "seitsemättätoista", "seitsemännessätoista", "seitsemännestätoista", "seitsemänteentoista", "seitsemännellätoista", "seitsemänneltätoista", "seitsemännelletoista", "seitsemäntenätoista", "seitsemänneksitoista", "seitsemänsintoista", "seitsemännettätoista", "seitsemänsinetoista" ) ) self.assertEqual( tuple(n2f(17, to="ordinal", case=c, plural=True) for c in CASES), ( "seitsemännettoista", "seitsemänsientoista", "seitsemänsiätoista", "seitsemänsissätoista", "seitsemänsistätoista", "seitsemänsiintoista", "seitsemänsillätoista", "seitsemänsiltätoista", "seitsemänsilletoista", "seitsemänsinätoista", "seitsemänsiksitoista", "seitsemänsintoista", "seitsemänsittätoista", "seitsemänsinetoista" ) ) # eighteen self.assertEqual( tuple(n2f(18, to="ordinal", case=c) for c in CASES), ( "kahdeksastoista", "kahdeksannentoista", "kahdeksattatoista", "kahdeksannessatoista", "kahdeksannestatoista", "kahdeksanteentoista", "kahdeksannellatoista", "kahdeksanneltatoista", "kahdeksannelletoista", "kahdeksantenatoista", "kahdeksanneksitoista", "kahdeksansintoista", "kahdeksannettatoista", "kahdeksansinetoista" ) ) self.assertEqual( tuple(n2f(18, to="ordinal", case=c, plural=True) for c in CASES), ( "kahdeksannettoista", "kahdeksansientoista", "kahdeksansiatoista", "kahdeksansissatoista", "kahdeksansistatoista", "kahdeksansiintoista", "kahdeksansillatoista", "kahdeksansiltatoista", "kahdeksansilletoista", "kahdeksansinatoista", "kahdeksansiksitoista", "kahdeksansintoista", "kahdeksansittatoista", "kahdeksansinetoista" ) ) # nineteen self.assertEqual( tuple(n2f(19, to="ordinal", case=c) for c in CASES), ( "yhdeksästoista", "yhdeksännentoista", "yhdeksättätoista", "yhdeksännessätoista", "yhdeksännestätoista", "yhdeksänteentoista", "yhdeksännellätoista", "yhdeksänneltätoista", "yhdeksännelletoista", "yhdeksäntenätoista", "yhdeksänneksitoista", "yhdeksänsintoista", "yhdeksännettätoista", "yhdeksänsinetoista" ) ) self.assertEqual( tuple(n2f(19, to="ordinal", case=c, plural=True) for c in CASES), ( "yhdeksännettoista", "yhdeksänsientoista", "yhdeksänsiätoista", "yhdeksänsissätoista", "yhdeksänsistätoista", "yhdeksänsiintoista", "yhdeksänsillätoista", "yhdeksänsiltätoista", "yhdeksänsilletoista", "yhdeksänsinätoista", "yhdeksänsiksitoista", "yhdeksänsintoista", "yhdeksänsittätoista", "yhdeksänsinetoista" ) ) # twenty self.assertEqual( tuple(n2f(20, to="ordinal", case=c) for c in CASES), ( "kahdeskymmenes", "kahdennenkymmenennen", "kahdettakymmenettä", "kahdennessakymmenennessä", "kahdennestakymmenennestä", "kahdenteenkymmenenteen", "kahdennellakymmenennellä", "kahdenneltakymmenenneltä", "kahdennellekymmenennelle", "kahdentenakymmenentenä", "kahdenneksikymmenenneksi", "kahdensinkymmenensin", "kahdennettakymmenennettä", "kahdensinekymmenensine" ) ) self.assertEqual( tuple(n2f(20, to="ordinal", case=c, plural=True) for c in CASES), ( "kahdennetkymmenennet", "kahdensienkymmenensien", "kahdensiakymmenensiä", "kahdensissakymmenensissä", "kahdensistakymmenensistä", "kahdensiinkymmenensiin", "kahdensillakymmenensillä", "kahdensiltakymmenensiltä", "kahdensillekymmenensille", "kahdensinakymmenensinä", "kahdensiksikymmenensiksi", "kahdensinkymmenensin", "kahdensittakymmenensittä", "kahdensinekymmenensine" ) ) def test_mid(self): # thirty self.assertEqual( tuple(n2f(30, to="cardinal", case=c) for c in CASES), ("kolmekymmentä", "kolmenkymmenen", "kolmeakymmentä", "kolmessakymmenessä", "kolmestakymmenestä", "kolmeenkymmeneen", "kolmellakymmenellä", "kolmeltakymmeneltä", "kolmellekymmenelle", "kolmenakymmenenä", "kolmeksikymmeneksi", "kolmenkymmenin", "kolmettakymmenettä", "kolminekymmenine") ) self.assertEqual( tuple(n2f(30, to="cardinal", case=c, plural=True) for c in CASES), ("kolmetkymmenet", "kolmienkymmenien", "kolmiakymmeniä", "kolmissakymmenissä", "kolmistakymmenistä", "kolmiinkymmeniin", "kolmillakymmenillä", "kolmiltakymmeniltä", "kolmillekymmenille", "kolminakymmeninä", "kolmiksikymmeniksi", "kolminkymmenin", "kolmittakymmenittä", "kolminekymmenine") ) # forty self.assertEqual( tuple(n2f(40, to="cardinal", case=c) for c in CASES), ("neljäkymmentä", "neljänkymmenen", "neljääkymmentä", "neljässäkymmenessä", "neljästäkymmenestä", "neljäänkymmeneen", "neljälläkymmenellä", "neljältäkymmeneltä", "neljällekymmenelle", "neljänäkymmenenä", "neljäksikymmeneksi", "neljinkymmenin", "neljättäkymmenettä", "neljinekymmenine") ) self.assertEqual( tuple(n2f(40, to="cardinal", case=c, plural=True) for c in CASES), ("neljätkymmenet", "neljienkymmenien", "neljiäkymmeniä", "neljissäkymmenissä", "neljistäkymmenistä", "neljiinkymmeniin", "neljilläkymmenillä", "neljiltäkymmeniltä", "neljillekymmenille", "neljinäkymmeninä", "neljiksikymmeniksi", "neljinkymmenin", "neljittäkymmenittä", "neljinekymmenine") ) # fifty self.assertEqual( tuple(n2f(50, to="cardinal", case=c) for c in CASES), ("viisikymmentä", "viidenkymmenen", "viittäkymmentä", "viidessäkymmenessä", "viidestäkymmenestä", "viiteenkymmeneen", "viidelläkymmenellä", "viideltäkymmeneltä", "viidellekymmenelle", "viitenäkymmenenä", "viideksikymmeneksi", "viisinkymmenin", "viidettäkymmenettä", "viisinekymmenine") ) self.assertEqual( tuple(n2f(50, to="cardinal", case=c, plural=True) for c in CASES), ("viidetkymmenet", "viisienkymmenien", "viisiäkymmeniä", "viisissäkymmenissä", "viisistäkymmenistä", "viisiinkymmeniin", "viisilläkymmenillä", "viisiltäkymmeniltä", "viisillekymmenille", "viisinäkymmeninä", "viisiksikymmeniksi", "viisinkymmenin", "viisittäkymmenittä", "viisinekymmenine") ) # sixty self.assertEqual( tuple(n2f(60, to="cardinal", case=c) for c in CASES), ("kuusikymmentä", "kuudenkymmenen", "kuuttakymmentä", "kuudessakymmenessä", "kuudestakymmenestä", "kuuteenkymmeneen", "kuudellakymmenellä", "kuudeltakymmeneltä", "kuudellekymmenelle", "kuutenakymmenenä", "kuudeksikymmeneksi", "kuusinkymmenin", "kuudettakymmenettä", "kuusinekymmenine") ) self.assertEqual( tuple(n2f(60, to="cardinal", case=c, plural=True) for c in CASES), ("kuudetkymmenet", "kuusienkymmenien", "kuusiakymmeniä", "kuusissakymmenissä", "kuusistakymmenistä", "kuusiinkymmeniin", "kuusillakymmenillä", "kuusiltakymmeniltä", "kuusillekymmenille", "kuusinakymmeninä", "kuusiksikymmeniksi", "kuusinkymmenin", "kuusittakymmenittä", "kuusinekymmenine") ) # seventy self.assertEqual( tuple(n2f(70, to="cardinal", case=c) for c in CASES), ( "seitsemänkymmentä", "seitsemänkymmenen", "seitsemääkymmentä", "seitsemässäkymmenessä", "seitsemästäkymmenestä", "seitsemäänkymmeneen", "seitsemälläkymmenellä", "seitsemältäkymmeneltä", "seitsemällekymmenelle", "seitsemänäkymmenenä", "seitsemäksikymmeneksi", "seitseminkymmenin", "seitsemättäkymmenettä", "seitseminekymmenine" ) ) self.assertEqual( tuple(n2f(70, to="cardinal", case=c, plural=True) for c in CASES), ( "seitsemätkymmenet", "seitsemienkymmenien", "seitsemiäkymmeniä", "seitsemissäkymmenissä", "seitsemistäkymmenistä", "seitsemiinkymmeniin", "seitsemilläkymmenillä", "seitsemiltäkymmeniltä", "seitsemillekymmenille", "seitseminäkymmeninä", "seitsemiksikymmeniksi", "seitseminkymmenin", "seitsemittäkymmenittä", "seitseminekymmenine" ) ) # eighty self.assertEqual( tuple(n2f(80, to="cardinal", case=c) for c in CASES), ( "kahdeksankymmentä", "kahdeksankymmenen", "kahdeksaakymmentä", "kahdeksassakymmenessä", "kahdeksastakymmenestä", "kahdeksaankymmeneen", "kahdeksallakymmenellä", "kahdeksaltakymmeneltä", "kahdeksallekymmenelle", "kahdeksanakymmenenä", "kahdeksaksikymmeneksi", "kahdeksinkymmenin", "kahdeksattakymmenettä", "kahdeksinekymmenine" ) ) self.assertEqual( tuple(n2f(80, to="cardinal", case=c, plural=True) for c in CASES), ( "kahdeksatkymmenet", "kahdeksienkymmenien", "kahdeksiakymmeniä", "kahdeksissakymmenissä", "kahdeksistakymmenistä", "kahdeksiinkymmeniin", "kahdeksillakymmenillä", "kahdeksiltakymmeniltä", "kahdeksillekymmenille", "kahdeksinakymmeninä", "kahdeksiksikymmeniksi", "kahdeksinkymmenin", "kahdeksittakymmenittä", "kahdeksinekymmenine" ) ) # ninety self.assertEqual( tuple(n2f(90, to="cardinal", case=c) for c in CASES), ( "yhdeksänkymmentä", "yhdeksänkymmenen", "yhdeksääkymmentä", "yhdeksässäkymmenessä", "yhdeksästäkymmenestä", "yhdeksäänkymmeneen", "yhdeksälläkymmenellä", "yhdeksältäkymmeneltä", "yhdeksällekymmenelle", "yhdeksänäkymmenenä", "yhdeksäksikymmeneksi", "yhdeksinkymmenin", "yhdeksättäkymmenettä", "yhdeksinekymmenine" ) ) self.assertEqual( tuple(n2f(90, to="cardinal", case=c, plural=True) for c in CASES), ( "yhdeksätkymmenet", "yhdeksienkymmenien", "yhdeksiäkymmeniä", "yhdeksissäkymmenissä", "yhdeksistäkymmenistä", "yhdeksiinkymmeniin", "yhdeksilläkymmenillä", "yhdeksiltäkymmeniltä", "yhdeksillekymmenille", "yhdeksinäkymmeninä", "yhdeksiksikymmeniksi", "yhdeksinkymmenin", "yhdeksittäkymmenittä", "yhdeksinekymmenine" ) ) # one hundred self.assertEqual( tuple(n2f(100, to="cardinal", case=c) for c in CASES), ("sata", "sadan", "sataa", "sadassa", "sadasta", "sataan", "sadalla", "sadalta", "sadalle", "satana", "sadaksi", "sadoin", "sadatta", "satoine") ) self.assertEqual( tuple(n2f(100, to="cardinal", case=c, plural=True) for c in CASES), ("sadat", "satojen", "satoja", "sadoissa", "sadoista", "satoihin", "sadoilla", "sadoilta", "sadoille", "satoina", "sadoiksi", "sadoin", "sadoitta", "satoine") ) # one hundred and twenty-three self.assertEqual( tuple(n2f(123, to="cardinal", case=c) for c in CASES), ( "satakaksikymmentäkolme", "sadankahdenkymmenenkolmen", "sataakahtakymmentäkolmea", "sadassakahdessakymmenessäkolmessa", "sadastakahdestakymmenestäkolmesta", "sataankahteenkymmeneenkolmeen", "sadallakahdellakymmenelläkolmella", "sadaltakahdeltakymmeneltäkolmelta", "sadallekahdellekymmenellekolmelle", "satanakahtenakymmenenäkolmena", "sadaksikahdeksikymmeneksikolmeksi", "sadoinkaksinkymmeninkolmen", "sadattakahdettakymmenettäkolmetta", "satoinekaksinekymmeninekolmine" ) ) self.assertEqual( tuple(n2f(123, to="cardinal", case=c, plural=True) for c in CASES), ( "sadatkahdetkymmenetkolmet", "satojenkaksienkymmenienkolmien", "satojakaksiakymmeniäkolmia", "sadoissakaksissakymmenissäkolmissa", "sadoistakaksistakymmenistäkolmista", "satoihinkaksiinkymmeniinkolmiin", "sadoillakaksillakymmenilläkolmilla", "sadoiltakaksiltakymmeniltäkolmilta", "sadoillekaksillekymmenillekolmille", "satoinakaksinakymmeninäkolmina", "sadoiksikaksiksikymmeniksikolmiksi", "sadoinkaksinkymmeninkolmin", "sadoittakaksittakymmenittäkolmitta", "satoinekaksinekymmeninekolmine" ) ) # one thousand self.assertEqual( tuple(n2f(1000, to="cardinal", case=c) for c in CASES), ("tuhat", "tuhannen", "tuhatta", "tuhannessa", "tuhannesta", "tuhanteen", "tuhannella", "tuhannelta", "tuhannelle", "tuhantena", "tuhanneksi", "tuhansin", "tuhannetta", "tuhansine") ) self.assertEqual( tuple(n2f(1000, to="cardinal", case=c, plural=True) for c in CASES), ("tuhannet", "tuhansien", "tuhansia", "tuhansissa", "tuhansista", "tuhansiin", "tuhansilla", "tuhansilta", "tuhansille", "tuhansina", "tuhansiksi", "tuhansin", "tuhansitta", "tuhansine") ) # one thousand, two hundred and thirty-four self.assertEqual( tuple(n2f(1234, to="cardinal", case=c) for c in CASES), ( "tuhat kaksisataakolmekymmentäneljä", "tuhannen kahdensadankolmenkymmenenneljän", "tuhatta kahtasataakolmeakymmentäneljää", "tuhannessa kahdessasadassakolmessakymmenessäneljässä", "tuhannesta kahdestasadastakolmestakymmenestäneljästä", "tuhanteen kahteensataankolmeenkymmeneenneljään", "tuhannella kahdellasadallakolmellakymmenelläneljällä", "tuhannelta kahdeltasadaltakolmeltakymmeneltäneljältä", "tuhannelle kahdellesadallekolmellekymmenelleneljälle", "tuhantena kahtenasatanakolmenakymmenenäneljänä", "tuhanneksi kahdeksisadaksikolmeksikymmeneksineljäksi", "tuhansin kaksinsadoinkolmenkymmeninneljin", "tuhannetta kahdettasadattakolmettakymmenettäneljättä", "tuhansine kaksinesatoinekolminekymmenineneljine" ) ) self.assertEqual( tuple(n2f(1234, to="cardinal", case=c, plural=True) for c in CASES), ( "tuhannet kahdetsadatkolmetkymmenetneljät", "tuhansien kaksiensatojenkolmienkymmenienneljien", "tuhansia kaksiasatojakolmiakymmeniäneljiä", "tuhansissa kaksissasadoissakolmissakymmenissäneljissä", "tuhansista kaksistasadoistakolmistakymmenistäneljistä", "tuhansiin kaksiinsatoihinkolmiinkymmeniinneljiin", "tuhansilla kaksillasadoillakolmillakymmenilläneljillä", "tuhansilta kaksiltasadoiltakolmiltakymmeniltäneljiltä", "tuhansille kaksillesadoillekolmillekymmenilleneljille", "tuhansina kaksinasatoinakolminakymmeninäneljinä", "tuhansiksi kaksiksisadoiksikolmiksikymmeniksineljiksi", "tuhansin kaksinsadoinkolminkymmeninneljin", "tuhansitta kaksittasadoittakolmittakymmenittäneljittä", "tuhansine kaksinesatoinekolminekymmenineneljine" ) ) def test_mid_ord(self): # thirty self.assertEqual( tuple(n2f(30, to="ordinal", case=c) for c in CASES), ( "kolmaskymmenes", "kolmannenkymmenennen", "kolmattakymmenettä", "kolmannessakymmenennessä", "kolmannestakymmenennestä", "kolmanteenkymmenenteen", "kolmannellakymmenennellä", "kolmanneltakymmenenneltä", "kolmannellekymmenennelle", "kolmantenakymmenentenä", "kolmanneksikymmenenneksi", "kolmansinkymmenensin", "kolmannettakymmenennettä", "kolmansinekymmenensine" ) ) self.assertEqual( tuple(n2f(30, to="ordinal", case=c, plural=True) for c in CASES), ( "kolmannetkymmenennet", "kolmansienkymmenensien", "kolmansiakymmenensiä", "kolmansissakymmenensissä", "kolmansistakymmenensistä", "kolmansiinkymmenensiin", "kolmansillakymmenensillä", "kolmansiltakymmenensiltä", "kolmansillekymmenensille", "kolmansinakymmenensinä", "kolmansiksikymmenensiksi", "kolmansinkymmenensin", "kolmansittakymmenensittä", "kolmansinekymmenensine" ) ) # forty self.assertEqual( tuple(n2f(40, to="ordinal", case=c) for c in CASES), ( "neljäskymmenes", "neljännenkymmenennen", "neljättäkymmenettä", "neljännessäkymmenennessä", "neljännestäkymmenennestä", "neljänteenkymmenenteen", "neljännelläkymmenennellä", "neljänneltäkymmenenneltä", "neljännellekymmenennelle", "neljäntenäkymmenentenä", "neljänneksikymmenenneksi", "neljänsinkymmenensin", "neljännettäkymmenennettä", "neljänsinekymmenensine" ) ) self.assertEqual( tuple(n2f(40, to="ordinal", case=c, plural=True) for c in CASES), ( "neljännetkymmenennet", "neljänsienkymmenensien", "neljänsiäkymmenensiä", "neljänsissäkymmenensissä", "neljänsistäkymmenensistä", "neljänsiinkymmenensiin", "neljänsilläkymmenensillä", "neljänsiltäkymmenensiltä", "neljänsillekymmenensille", "neljänsinäkymmenensinä", "neljänsiksikymmenensiksi", "neljänsinkymmenensin", "neljänsittäkymmenensittä", "neljänsinekymmenensine" ) ) # fifty self.assertEqual( tuple(n2f(50, to="ordinal", case=c) for c in CASES), ( "viideskymmenes", "viidennenkymmenennen", "viidettäkymmenettä", "viidennessäkymmenennessä", "viidennestäkymmenennestä", "viidenteenkymmenenteen", "viidennelläkymmenennellä", "viidenneltäkymmenenneltä", "viidennellekymmenennelle", "viidentenäkymmenentenä", "viidenneksikymmenenneksi", "viidensinkymmenensin", "viidennettäkymmenennettä", "viidensinekymmenensine" ) ) self.assertEqual( tuple(n2f(50, to="ordinal", case=c, plural=True) for c in CASES), ( "viidennetkymmenennet", "viidensienkymmenensien", "viidensiäkymmenensiä", "viidensissäkymmenensissä", "viidensistäkymmenensistä", "viidensiinkymmenensiin", "viidensilläkymmenensillä", "viidensiltäkymmenensiltä", "viidensillekymmenensille", "viidensinäkymmenensinä", "viidensiksikymmenensiksi", "viidensinkymmenensin", "viidensittäkymmenensittä", "viidensinekymmenensine" ) ) # sixty self.assertEqual( tuple(n2f(60, to="ordinal", case=c) for c in CASES), ( "kuudeskymmenes", "kuudennenkymmenennen", "kuudettakymmenettä", "kuudennessakymmenennessä", "kuudennestakymmenennestä", "kuudenteenkymmenenteen", "kuudennellakymmenennellä", "kuudenneltakymmenenneltä", "kuudennellekymmenennelle", "kuudentenakymmenentenä", "kuudenneksikymmenenneksi", "kuudensinkymmenensin", "kuudennettakymmenennettä", "kuudensinekymmenensine" ) ) self.assertEqual( tuple(n2f(60, to="ordinal", case=c, plural=True) for c in CASES), ( "kuudennetkymmenennet", "kuudensienkymmenensien", "kuudensiakymmenensiä", "kuudensissakymmenensissä", "kuudensistakymmenensistä", "kuudensiinkymmenensiin", "kuudensillakymmenensillä", "kuudensiltakymmenensiltä", "kuudensillekymmenensille", "kuudensinakymmenensinä", "kuudensiksikymmenensiksi", "kuudensinkymmenensin", "kuudensittakymmenensittä", "kuudensinekymmenensine" ) ) # seventy self.assertEqual( tuple(n2f(70, to="ordinal", case=c) for c in CASES), ( "seitsemäskymmenes", "seitsemännenkymmenennen", "seitsemättäkymmenettä", "seitsemännessäkymmenennessä", "seitsemännestäkymmenennestä", "seitsemänteenkymmenenteen", "seitsemännelläkymmenennellä", "seitsemänneltäkymmenenneltä", "seitsemännellekymmenennelle", "seitsemäntenäkymmenentenä", "seitsemänneksikymmenenneksi", "seitsemänsinkymmenensin", "seitsemännettäkymmenennettä", "seitsemänsinekymmenensine" ) ) self.assertEqual( tuple(n2f(70, to="ordinal", case=c, plural=True) for c in CASES), ( "seitsemännetkymmenennet", "seitsemänsienkymmenensien", "seitsemänsiäkymmenensiä", "seitsemänsissäkymmenensissä", "seitsemänsistäkymmenensistä", "seitsemänsiinkymmenensiin", "seitsemänsilläkymmenensillä", "seitsemänsiltäkymmenensiltä", "seitsemänsillekymmenensille", "seitsemänsinäkymmenensinä", "seitsemänsiksikymmenensiksi", "seitsemänsinkymmenensin", "seitsemänsittäkymmenensittä", "seitsemänsinekymmenensine" ) ) # eighty self.assertEqual( tuple(n2f(80, to="ordinal", case=c) for c in CASES), ( "kahdeksaskymmenes", "kahdeksannenkymmenennen", "kahdeksattakymmenettä", "kahdeksannessakymmenennessä", "kahdeksannestakymmenennestä", "kahdeksanteenkymmenenteen", "kahdeksannellakymmenennellä", "kahdeksanneltakymmenenneltä", "kahdeksannellekymmenennelle", "kahdeksantenakymmenentenä", "kahdeksanneksikymmenenneksi", "kahdeksansinkymmenensin", "kahdeksannettakymmenennettä", "kahdeksansinekymmenensine" ) ) self.assertEqual( tuple(n2f(80, to="ordinal", case=c, plural=True) for c in CASES), ( "kahdeksannetkymmenennet", "kahdeksansienkymmenensien", "kahdeksansiakymmenensiä", "kahdeksansissakymmenensissä", "kahdeksansistakymmenensistä", "kahdeksansiinkymmenensiin", "kahdeksansillakymmenensillä", "kahdeksansiltakymmenensiltä", "kahdeksansillekymmenensille", "kahdeksansinakymmenensinä", "kahdeksansiksikymmenensiksi", "kahdeksansinkymmenensin", "kahdeksansittakymmenensittä", "kahdeksansinekymmenensine" ) ) # ninety self.assertEqual( tuple(n2f(90, to="ordinal", case=c) for c in CASES), ( "yhdeksäskymmenes", "yhdeksännenkymmenennen", "yhdeksättäkymmenettä", "yhdeksännessäkymmenennessä", "yhdeksännestäkymmenennestä", "yhdeksänteenkymmenenteen", "yhdeksännelläkymmenennellä", "yhdeksänneltäkymmenenneltä", "yhdeksännellekymmenennelle", "yhdeksäntenäkymmenentenä", "yhdeksänneksikymmenenneksi", "yhdeksänsinkymmenensin", "yhdeksännettäkymmenennettä", "yhdeksänsinekymmenensine" ) ) self.assertEqual( tuple(n2f(90, to="ordinal", case=c, plural=True) for c in CASES), ( "yhdeksännetkymmenennet", "yhdeksänsienkymmenensien", "yhdeksänsiäkymmenensiä", "yhdeksänsissäkymmenensissä", "yhdeksänsistäkymmenensistä", "yhdeksänsiinkymmenensiin", "yhdeksänsilläkymmenensillä", "yhdeksänsiltäkymmenensiltä", "yhdeksänsillekymmenensille", "yhdeksänsinäkymmenensinä", "yhdeksänsiksikymmenensiksi", "yhdeksänsinkymmenensin", "yhdeksänsittäkymmenensittä", "yhdeksänsinekymmenensine" ) ) # one hundred self.assertEqual( tuple(n2f(100, to="ordinal", case=c) for c in CASES), ("sadas", "sadannen", "sadatta", "sadannessa", "sadannesta", "sadanteen", "sadannella", "sadannelta", "sadannelle", "sadantena", "sadanneksi", "sadansin", "sadannetta", "sadansine") ) self.assertEqual( tuple(n2f(100, to="ordinal", case=c, plural=True) for c in CASES), ("sadannet", "sadansien", "sadansia", "sadansissa", "sadansista", "sadansiin", "sadansilla", "sadansilta", "sadansille", "sadansina", "sadansiksi", "sadansin", "sadansitta", "sadansine") ) # one hundred and twenty-three self.assertEqual( tuple(n2f(123, to="ordinal", case=c) for c in CASES), ( "sadaskahdeskymmeneskolmas", "sadannenkahdennenkymmenennenkolmannen", "sadattakahdettakymmenettäkolmatta", "sadannessakahdennessakymmenennessäkolmannessa", "sadannestakahdennestakymmenennestäkolmannesta", "sadanteenkahdenteenkymmenenteenkolmanteen", "sadannellakahdennellakymmenennelläkolmannella", "sadanneltakahdenneltakymmenenneltäkolmannelta", "sadannellekahdennellekymmenennellekolmannelle", "sadantenakahdentenakymmenentenäkolmantena", "sadanneksikahdenneksikymmenenneksikolmanneksi", "sadansinkahdensinkymmenensinkolmansin", "sadannettakahdennettakymmenennettäkolmannetta", "sadansinekahdensinekymmenensinekolmansine" ) ) self.assertEqual( tuple(n2f(123, to="ordinal", case=c, plural=True) for c in CASES), ( "sadannetkahdennetkymmenennetkolmannet", "sadansienkahdensienkymmenensienkolmansien", "sadansiakahdensiakymmenensiäkolmansia", "sadansissakahdensissakymmenensissäkolmansissa", "sadansistakahdensistakymmenensistäkolmansista", "sadansiinkahdensiinkymmenensiinkolmansiin", "sadansillakahdensillakymmenensilläkolmansilla", "sadansiltakahdensiltakymmenensiltäkolmansilta", "sadansillekahdensillekymmenensillekolmansille", "sadansinakahdensinakymmenensinäkolmansina", "sadansiksikahdensiksikymmenensiksikolmansiksi", "sadansinkahdensinkymmenensinkolmansin", "sadansittakahdensittakymmenensittäkolmansitta", "sadansinekahdensinekymmenensinekolmansine" ) ) # one thousand self.assertEqual( tuple(n2f(1000, to="ordinal", case=c) for c in CASES), ("tuhannes", "tuhannennen", "tuhannetta", "tuhannennessa", "tuhannennesta", "tuhannenteen", "tuhannennella", "tuhannennelta", "tuhannennelle", "tuhannentena", "tuhannenneksi", "tuhannensin", "tuhannennetta", "tuhannensine") ) self.assertEqual( tuple(n2f(1000, to="ordinal", case=c, plural=True) for c in CASES), ("tuhannennet", "tuhannensien", "tuhannensia", "tuhannensissa", "tuhannensista", "tuhannensiin", "tuhannensilla", "tuhannensilta", "tuhannensille", "tuhannensina", "tuhannensiksi", "tuhannensin", "tuhannensitta", "tuhannensine") ) # one thousand, two hundred and thirty-four self.assertEqual( tuple(n2f(1234, to="ordinal", case=c) for c in CASES), ( "tuhannes kahdessadaskolmaskymmenesneljäs", "tuhannennen kahdennensadannenkolmannenkymmenennenneljännen", "tuhannetta kahdettasadattakolmattakymmenettäneljättä", "tuhannennessa kahdennessasadannessa" "kolmannessakymmenennessäneljännessä", "tuhannennesta kahdennestasadannesta" "kolmannestakymmenennestäneljännestä", "tuhannenteen kahdenteensadanteen" "kolmanteenkymmenenteenneljänteen", "tuhannennella kahdennellasadannella" "kolmannellakymmenennelläneljännellä", "tuhannennelta kahdenneltasadannelta" "kolmanneltakymmenenneltäneljänneltä", "tuhannennelle kahdennellesadannelle" "kolmannellekymmenennelleneljännelle", "tuhannentena kahdentenasadantena" "kolmantenakymmenentenäneljäntenä", "tuhannenneksi kahdenneksisadanneksi" "kolmanneksikymmenenneksineljänneksi", "tuhannensin kahdensinsadansin" "kolmansinkymmenensinneljänsin", "tuhannennetta kahdennettasadannetta" "kolmannettakymmenennettäneljännettä", "tuhannensine kahdensinesadansine" "kolmansinekymmenensineneljänsine" ) ) self.assertEqual( tuple(n2f(1234, to="ordinal", case=c, plural=True) for c in CASES), ( "tuhannennet kahdennetsadannet" "kolmannetkymmenennetneljännet", "tuhannensien kahdensiensadansien" "kolmansienkymmenensienneljänsien", "tuhannensia kahdensiasadansia" "kolmansiakymmenensiäneljänsiä", "tuhannensissa kahdensissasadansissa" "kolmansissakymmenensissäneljänsissä", "tuhannensista kahdensistasadansista" "kolmansistakymmenensistäneljänsistä", "tuhannensiin kahdensiinsadansiin" "kolmansiinkymmenensiinneljänsiin", "tuhannensilla kahdensillasadansilla" "kolmansillakymmenensilläneljänsillä", "tuhannensilta kahdensiltasadansilta" "kolmansiltakymmenensiltäneljänsiltä", "tuhannensille kahdensillesadansille" "kolmansillekymmenensilleneljänsille", "tuhannensina kahdensinasadansina" "kolmansinakymmenensinäneljänsinä", "tuhannensiksi kahdensiksisadansiksi" "kolmansiksikymmenensiksineljänsiksi", "tuhannensin kahdensinsadansin" "kolmansinkymmenensinneljänsin", "tuhannensitta kahdensittasadansitta" "kolmansittakymmenensittäneljänsittä", "tuhannensine kahdensinesadansine" "kolmansinekymmenensineneljänsine" ) ) def test_high(self): # ten thousand self.assertEqual( tuple(n2f(10000, to="cardinal", case=c) for c in CASES), ( "kymmenentuhatta", "kymmenentuhannen", "kymmentätuhatta", "kymmenessätuhannessa", "kymmenestätuhannesta", "kymmeneentuhanteen", "kymmenellätuhannella", "kymmeneltätuhannelta", "kymmenelletuhannelle", "kymmenenätuhantena", "kymmeneksituhanneksi", "kymmenintuhansin", "kymmenettätuhannetta", "kymmeninetuhansine" ) ) self.assertEqual( tuple(n2f(10000, to="cardinal", case=c, plural=True) for c in CASES), ( "kymmenettuhannet", "kymmenientuhansien", "kymmeniätuhansia", "kymmenissätuhansissa", "kymmenistätuhansista", "kymmeniintuhansiin", "kymmenillätuhansilla", "kymmeniltätuhansilta", "kymmenilletuhansille", "kymmeninätuhansina", "kymmeniksituhansiksi", "kymmenintuhansin", "kymmenittätuhansitta", "kymmeninetuhansine" ) ) # twelve thousand, three hundred and forty-five self.assertEqual( tuple(n2f(12345, to="cardinal", case=c) for c in CASES), ( "kaksitoistatuhatta " "kolmesataaneljäkymmentäviisi", "kahdentoistatuhannen " "kolmensadanneljänkymmenenviiden", "kahtatoistatuhatta " "kolmeasataaneljääkymmentäviittä", "kahdessatoistatuhannessa " "kolmessasadassaneljässäkymmenessäviidessä", "kahdestatoistatuhannesta " "kolmestasadastaneljästäkymmenestäviidestä", "kahteentoistatuhanteen " "kolmeensataanneljäänkymmeneenviiteen", "kahdellatoistatuhannella " "kolmellasadallaneljälläkymmenelläviidellä", "kahdeltatoistatuhannelta " "kolmeltasadaltaneljältäkymmeneltäviideltä", "kahdelletoistatuhannelle " "kolmellesadalleneljällekymmenelleviidelle", "kahtenatoistatuhantena " "kolmenasatananeljänäkymmenenäviitenä", "kahdeksitoistatuhanneksi " "kolmeksisadaksineljäksikymmeneksiviideksi", "kaksintoistatuhansin " "kolmensadoinneljinkymmeninviisin", "kahdettatoistatuhannetta " "kolmettasadattaneljättäkymmenettäviidettä", "kaksinetoistatuhansine " "kolminesatoineneljinekymmenineviisine" ) ) self.assertEqual( tuple(n2f( 12345, to="cardinal", case=c, plural=True) for c in CASES), ( "kahdettoistatuhannet " "kolmetsadatneljätkymmenetviidet", "kaksientoistatuhansien " "kolmiensatojenneljienkymmenienviisien", "kaksiatoistatuhansia " "kolmiasatojaneljiäkymmeniäviisiä", "kaksissatoistatuhansissa " "kolmissasadoissaneljissäkymmenissäviisissä", "kaksistatoistatuhansista " "kolmistasadoistaneljistäkymmenistäviisistä", "kaksiintoistatuhansiin " "kolmiinsatoihinneljiinkymmeniinviisiin", "kaksillatoistatuhansilla " "kolmillasadoillaneljilläkymmenilläviisillä", "kaksiltatoistatuhansilta " "kolmiltasadoiltaneljiltäkymmeniltäviisiltä", "kaksilletoistatuhansille " "kolmillesadoilleneljillekymmenilleviisille", "kaksinatoistatuhansina " "kolminasatoinaneljinäkymmeninäviisinä", "kaksiksitoistatuhansiksi " "kolmiksisadoiksineljiksikymmeniksiviisiksi", "kaksintoistatuhansin " "kolminsadoinneljinkymmeninviisin", "kaksittatoistatuhansitta " "kolmittasadoittaneljittäkymmenittäviisittä", "kaksinetoistatuhansine " "kolminesatoineneljinekymmenineviisine" ) ) # one hundred thousand self.assertEqual( tuple(n2f(100000, to="cardinal", case=c) for c in CASES), ("satatuhatta", "sadantuhannen", "sataatuhatta", "sadassatuhannessa", "sadastatuhannesta", "sataantuhanteen", "sadallatuhannella", "sadaltatuhannelta", "sadalletuhannelle", "satanatuhantena", "sadaksituhanneksi", "sadointuhansin", "sadattatuhannetta", "satoinetuhansine") ) self.assertEqual( tuple(n2f(100000, to="cardinal", case=c, plural=True) for c in CASES), ("sadattuhannet", "satojentuhansien", "satojatuhansia", "sadoissatuhansissa", "sadoistatuhansista", "satoihintuhansiin", "sadoillatuhansilla", "sadoiltatuhansilta", "sadoilletuhansille", "satoinatuhansina", "sadoiksituhansiksi", "sadointuhansin", "sadoittatuhansitta", "satoinetuhansine") ) # one hundred and twenty-three thousand, four hundred and fifty-six self.assertEqual( tuple(n2f(123456, to="cardinal", case=c) for c in CASES), ( "satakaksikymmentäkolmetuhatta " "neljäsataaviisikymmentäkuusi", "sadankahdenkymmenenkolmentuhannen " "neljänsadanviidenkymmenenkuuden", "sataakahtakymmentäkolmeatuhatta " "neljääsataaviittäkymmentäkuutta", "sadassakahdessakymmenessäkolmessatuhannessa " "neljässäsadassaviidessäkymmenessäkuudessa", "sadastakahdestakymmenestäkolmestatuhannesta " "neljästäsadastaviidestäkymmenestäkuudesta", "sataankahteenkymmeneenkolmeentuhanteen " "neljäänsataanviiteenkymmeneenkuuteen", "sadallakahdellakymmenelläkolmellatuhannella " "neljälläsadallaviidelläkymmenelläkuudella", "sadaltakahdeltakymmeneltäkolmeltatuhannelta " "neljältäsadaltaviideltäkymmeneltäkuudelta", "sadallekahdellekymmenellekolmelletuhannelle " "neljällesadalleviidellekymmenellekuudelle", "satanakahtenakymmenenäkolmenatuhantena " "neljänäsatanaviitenäkymmenenäkuutena", "sadaksikahdeksikymmeneksikolmeksituhanneksi " "neljäksisadaksiviideksikymmeneksikuudeksi", "sadoinkaksinkymmeninkolmentuhansin " "neljinsadoinviisinkymmeninkuusin", "sadattakahdettakymmenettäkolmettatuhannetta " "neljättäsadattaviidettäkymmenettäkuudetta", "satoinekaksinekymmeninekolminetuhansine " "neljinesatoineviisinekymmeninekuusine" ) ) self.assertEqual( tuple(n2f(123456, to="cardinal", case=c, plural=True) for c in CASES), ( "sadatkahdetkymmenetkolmettuhannet " "neljätsadatviidetkymmenetkuudet", "satojenkaksienkymmenienkolmientuhansien " "neljiensatojenviisienkymmenienkuusien", "satojakaksiakymmeniäkolmiatuhansia " "neljiäsatojaviisiäkymmeniäkuusia", "sadoissakaksissakymmenissäkolmissatuhansissa " "neljissäsadoissaviisissäkymmenissäkuusissa", "sadoistakaksistakymmenistäkolmistatuhansista " "neljistäsadoistaviisistäkymmenistäkuusista", "satoihinkaksiinkymmeniinkolmiintuhansiin " "neljiinsatoihinviisiinkymmeniinkuusiin", "sadoillakaksillakymmenilläkolmillatuhansilla " "neljilläsadoillaviisilläkymmenilläkuusilla", "sadoiltakaksiltakymmeniltäkolmiltatuhansilta " "neljiltäsadoiltaviisiltäkymmeniltäkuusilta", "sadoillekaksillekymmenillekolmilletuhansille " "neljillesadoilleviisillekymmenillekuusille", "satoinakaksinakymmeninäkolminatuhansina " "neljinäsatoinaviisinäkymmeninäkuusina", "sadoiksikaksiksikymmeniksikolmiksituhansiksi " "neljiksisadoiksiviisiksikymmeniksikuusiksi", "sadoinkaksinkymmeninkolmintuhansin " "neljinsadoinviisinkymmeninkuusin", "sadoittakaksittakymmenittäkolmittatuhansitta " "neljittäsadoittaviisittäkymmenittäkuusitta", "satoinekaksinekymmeninekolminetuhansine " "neljinesatoineviisinekymmeninekuusine" ) ) # one million self.assertEqual( tuple(n2f(10**6, to="cardinal", case=c) for c in CASES), ("miljoona", "miljoonan", "miljoonaa", "miljoonassa", "miljoonasta", "miljoonaan", "miljoonalla", "miljoonalta", "miljoonalle", "miljoonana", "miljoonaksi", "miljoonin", "miljoonatta", "miljoonine") ) self.assertEqual( tuple(n2f(10**6, to="cardinal", case=c, plural=True) for c in CASES), ("miljoonat", "miljoonien", "miljoonia", "miljoonissa", "miljoonista", "miljooniin", "miljoonilla", "miljoonilta", "miljoonille", "miljoonina", "miljooniksi", "miljoonin", "miljoonitta", "miljoonine") ) # one million, two hundred and thirty-four thousand, # five hundred and sixty-seven self.assertEqual( tuple(n2f(1234567, to="cardinal", case=c) for c in CASES), ( "miljoona " "kaksisataakolmekymmentäneljätuhatta " "viisisataakuusikymmentäseitsemän", "miljoonan " "kahdensadankolmenkymmenenneljäntuhannen " "viidensadankuudenkymmenenseitsemän", "miljoonaa " "kahtasataakolmeakymmentäneljäätuhatta " "viittäsataakuuttakymmentäseitsemää", "miljoonassa " "kahdessasadassakolmessakymmenessäneljässätuhannessa " "viidessäsadassakuudessakymmenessäseitsemässä", "miljoonasta " "kahdestasadastakolmestakymmenestäneljästätuhannesta " "viidestäsadastakuudestakymmenestäseitsemästä", "miljoonaan " "kahteensataankolmeenkymmeneenneljääntuhanteen " "viiteensataankuuteenkymmeneenseitsemään", "miljoonalla " "kahdellasadallakolmellakymmenelläneljällätuhannella " "viidelläsadallakuudellakymmenelläseitsemällä", "miljoonalta " "kahdeltasadaltakolmeltakymmeneltäneljältätuhannelta " "viideltäsadaltakuudeltakymmeneltäseitsemältä", "miljoonalle " "kahdellesadallekolmellekymmenelleneljälletuhannelle " "viidellesadallekuudellekymmenelleseitsemälle", "miljoonana " "kahtenasatanakolmenakymmenenäneljänätuhantena " "viitenäsatanakuutenakymmenenäseitsemänä", "miljoonaksi " "kahdeksisadaksikolmeksikymmeneksineljäksituhanneksi " "viideksisadaksikuudeksikymmeneksiseitsemäksi", "miljoonin " "kaksinsadoinkolmenkymmeninneljintuhansin " "viisinsadoinkuusinkymmeninseitsemin", "miljoonatta " "kahdettasadattakolmettakymmenettäneljättätuhannetta " "viidettäsadattakuudettakymmenettäseitsemättä", "miljoonine " "kaksinesatoinekolminekymmenineneljinetuhansine " "viisinesatoinekuusinekymmenineseitsemine" ) ) self.assertEqual( tuple(n2f(1234567, to="cardinal", case=c, plural=True) for c in CASES), ( "miljoonat " "kahdetsadatkolmetkymmenetneljättuhannet " "viidetsadatkuudetkymmenetseitsemät", "miljoonien " "kaksiensatojenkolmienkymmenienneljientuhansien " "viisiensatojenkuusienkymmenienseitsemien", "miljoonia " "kaksiasatojakolmiakymmeniäneljiätuhansia " "viisiäsatojakuusiakymmeniäseitsemiä", "miljoonissa " "kaksissasadoissakolmissakymmenissäneljissätuhansissa " "viisissäsadoissakuusissakymmenissäseitsemissä", "miljoonista " "kaksistasadoistakolmistakymmenistäneljistätuhansista " "viisistäsadoistakuusistakymmenistäseitsemistä", "miljooniin " "kaksiinsatoihinkolmiinkymmeniinneljiintuhansiin " "viisiinsatoihinkuusiinkymmeniinseitsemiin", "miljoonilla " "kaksillasadoillakolmillakymmenilläneljillätuhansilla " "viisilläsadoillakuusillakymmenilläseitsemillä", "miljoonilta " "kaksiltasadoiltakolmiltakymmeniltäneljiltätuhansilta " "viisiltäsadoiltakuusiltakymmeniltäseitsemiltä", "miljoonille " "kaksillesadoillekolmillekymmenilleneljilletuhansille " "viisillesadoillekuusillekymmenilleseitsemille", "miljoonina " "kaksinasatoinakolminakymmeninäneljinätuhansina " "viisinäsatoinakuusinakymmeninäseitseminä", "miljooniksi " "kaksiksisadoiksikolmiksikymmeniksineljiksituhansiksi " "viisiksisadoiksikuusiksikymmeniksiseitsemiksi", "miljoonin " "kaksinsadoinkolminkymmeninneljintuhansin " "viisinsadoinkuusinkymmeninseitsemin", "miljoonitta " "kaksittasadoittakolmittakymmenittäneljittätuhansitta " "viisittäsadoittakuusittakymmenittäseitsemittä", "miljoonine " "kaksinesatoinekolminekymmenineneljinetuhansine " "viisinesatoinekuusinekymmenineseitsemine" ) ) # one billion (short scale) self.assertEqual( tuple(n2f(10**9, to="cardinal", case=c) for c in CASES), ("miljardi", "miljardin", "miljardia", "miljardissa", "miljardista", "miljardiin", "miljardilla", "miljardilta", "miljardille", "miljardina", "miljardiksi", "miljardein", "miljarditta", "miljardeine") ) self.assertEqual( tuple(n2f(10**9, to="cardinal", case=c, plural=True) for c in CASES), ("miljardit", "miljardien", "miljardeja", "miljardeissa", "miljardeista", "miljardeihin", "miljardeilla", "miljardeilta", "miljardeille", "miljardeina", "miljardeiksi", "miljardein", "miljardeitta", "miljardeine") ) # one billion, two hundred and thirty-four million, # five hundred and sixty-seven thousand, eight hundred and ninety # (short scale) self.assertEqual( tuple(n2f(1234567890, to="cardinal", case=c) for c in CASES), ( "miljardi " "kaksisataakolmekymmentäneljämiljoonaa " "viisisataakuusikymmentäseitsemäntuhatta " "kahdeksansataayhdeksänkymmentä", "miljardin " "kahdensadankolmenkymmenenneljänmiljoonan " "viidensadankuudenkymmenenseitsemäntuhannen " "kahdeksansadanyhdeksänkymmenen", "miljardia " "kahtasataakolmeakymmentäneljäämiljoonaa " "viittäsataakuuttakymmentäseitsemäätuhatta " "kahdeksaasataayhdeksääkymmentä", "miljardissa " "kahdessasadassakolmessakymmenessäneljässämiljoonassa " "viidessäsadassakuudessakymmenessäseitsemässätuhannessa " "kahdeksassasadassayhdeksässäkymmenessä", "miljardista " "kahdestasadastakolmestakymmenestäneljästämiljoonasta " "viidestäsadastakuudestakymmenestäseitsemästätuhannesta " "kahdeksastasadastayhdeksästäkymmenestä", "miljardiin " "kahteensataankolmeenkymmeneenneljäänmiljoonaan " "viiteensataankuuteenkymmeneenseitsemääntuhanteen " "kahdeksaansataanyhdeksäänkymmeneen", "miljardilla " "kahdellasadallakolmellakymmenelläneljällämiljoonalla " "viidelläsadallakuudellakymmenelläseitsemällätuhannella " "kahdeksallasadallayhdeksälläkymmenellä", "miljardilta " "kahdeltasadaltakolmeltakymmeneltäneljältämiljoonalta " "viideltäsadaltakuudeltakymmeneltäseitsemältätuhannelta " "kahdeksaltasadaltayhdeksältäkymmeneltä", "miljardille " "kahdellesadallekolmellekymmenelleneljällemiljoonalle " "viidellesadallekuudellekymmenelleseitsemälletuhannelle " "kahdeksallesadalleyhdeksällekymmenelle", "miljardina " "kahtenasatanakolmenakymmenenäneljänämiljoonana " "viitenäsatanakuutenakymmenenäseitsemänätuhantena " "kahdeksanasatanayhdeksänäkymmenenä", "miljardiksi " "kahdeksisadaksikolmeksikymmeneksineljäksimiljoonaksi " "viideksisadaksikuudeksikymmeneksiseitsemäksituhanneksi " "kahdeksaksisadaksiyhdeksäksikymmeneksi", "miljardein " "kaksinsadoinkolmenkymmeninneljinmiljoonin " "viisinsadoinkuusinkymmeninseitsemintuhansin " "kahdeksinsadoinyhdeksinkymmenin", "miljarditta " "kahdettasadattakolmettakymmenettäneljättämiljoonatta " "viidettäsadattakuudettakymmenettäseitsemättätuhannetta " "kahdeksattasadattayhdeksättäkymmenettä", "miljardeine " "kaksinesatoinekolminekymmenineneljinemiljoonine " "viisinesatoinekuusinekymmenineseitseminetuhansine " "kahdeksinesatoineyhdeksinekymmenine" ) ) self.assertEqual( tuple(n2f(1234567890, to="cardinal", case=c, plural=True) for c in CASES), ( "miljardit " "kahdetsadatkolmetkymmenetneljätmiljoonat " "viidetsadatkuudetkymmenetseitsemättuhannet " "kahdeksatsadatyhdeksätkymmenet", "miljardien " "kaksiensatojenkolmienkymmenienneljienmiljoonien " "viisiensatojenkuusienkymmenienseitsemientuhansien " "kahdeksiensatojenyhdeksienkymmenien", "miljardeja " "kaksiasatojakolmiakymmeniäneljiämiljoonia " "viisiäsatojakuusiakymmeniäseitsemiätuhansia " "kahdeksiasatojayhdeksiäkymmeniä", "miljardeissa " "kaksissasadoissakolmissakymmenissäneljissämiljoonissa " "viisissäsadoissakuusissakymmenissäseitsemissätuhansissa " "kahdeksissasadoissayhdeksissäkymmenissä", "miljardeista " "kaksistasadoistakolmistakymmenistäneljistämiljoonista " "viisistäsadoistakuusistakymmenistäseitsemistätuhansista " "kahdeksistasadoistayhdeksistäkymmenistä", "miljardeihin " "kaksiinsatoihinkolmiinkymmeniinneljiinmiljooniin " "viisiinsatoihinkuusiinkymmeniinseitsemiintuhansiin " "kahdeksiinsatoihinyhdeksiinkymmeniin", "miljardeilla " "kaksillasadoillakolmillakymmenilläneljillämiljoonilla " "viisilläsadoillakuusillakymmenilläseitsemillätuhansilla " "kahdeksillasadoillayhdeksilläkymmenillä", "miljardeilta " "kaksiltasadoiltakolmiltakymmeniltäneljiltämiljoonilta " "viisiltäsadoiltakuusiltakymmeniltäseitsemiltätuhansilta " "kahdeksiltasadoiltayhdeksiltäkymmeniltä", "miljardeille " "kaksillesadoillekolmillekymmenilleneljillemiljoonille " "viisillesadoillekuusillekymmenilleseitsemilletuhansille " "kahdeksillesadoilleyhdeksillekymmenille", "miljardeina " "kaksinasatoinakolminakymmeninäneljinämiljoonina " "viisinäsatoinakuusinakymmeninäseitseminätuhansina " "kahdeksinasatoinayhdeksinäkymmeninä", "miljardeiksi " "kaksiksisadoiksikolmiksikymmeniksineljiksimiljooniksi " "viisiksisadoiksikuusiksikymmeniksiseitsemiksituhansiksi " "kahdeksiksisadoiksiyhdeksiksikymmeniksi", "miljardein " "kaksinsadoinkolminkymmeninneljinmiljoonin " "viisinsadoinkuusinkymmeninseitsemintuhansin " "kahdeksinsadoinyhdeksinkymmenin", "miljardeitta " "kaksittasadoittakolmittakymmenittäneljittämiljoonitta " "viisittäsadoittakuusittakymmenittäseitsemittätuhansitta " "kahdeksittasadoittayhdeksittäkymmenittä", "miljardeine " "kaksinesatoinekolminekymmenineneljinemiljoonine " "viisinesatoinekuusinekymmenineseitseminetuhansine " "kahdeksinesatoineyhdeksinekymmenine" ) ) # one trillion (short scale) self.assertEqual( tuple(n2f((10**6)**2, to="cardinal", case=c) for c in CASES), ("biljoona", "biljoonan", "biljoonaa", "biljoonassa", "biljoonasta", "biljoonaan", "biljoonalla", "biljoonalta", "biljoonalle", "biljoonana", "biljoonaksi", "biljoonin", "biljoonatta", "biljoonine") ) self.assertEqual( tuple(n2f((10**6)**2, to="cardinal", case=c, plural=True) for c in CASES), ("biljoonat", "biljoonien", "biljoonia", "biljoonissa", "biljoonista", "biljooniin", "biljoonilla", "biljoonilta", "biljoonille", "biljoonina", "biljooniksi", "biljoonin", "biljoonitta", "biljoonine") ) # one quintillion (short scale) self.assertEqual( tuple(n2f((10**6)**3, to="cardinal", case=c) for c in CASES), ("triljoona", "triljoonan", "triljoonaa", "triljoonassa", "triljoonasta", "triljoonaan", "triljoonalla", "triljoonalta", "triljoonalle", "triljoonana", "triljoonaksi", "triljoonin", "triljoonatta", "triljoonine") ) self.assertEqual( tuple(n2f((10**6)**3, to="cardinal", case=c, plural=True) for c in CASES), ("triljoonat", "triljoonien", "triljoonia", "triljoonissa", "triljoonista", "triljooniin", "triljoonilla", "triljoonilta", "triljoonille", "triljoonina", "triljooniksi", "triljoonin", "triljoonitta", "triljoonine") ) def test_high_ord(self): # ten thousand self.assertEqual( tuple(n2f(10000, to="ordinal", case=c) for c in CASES), ( "kymmenestuhannes", "kymmenennentuhannennen", "kymmenettätuhannetta", "kymmenennessätuhannennessa", "kymmenennestätuhannennesta", "kymmenenteentuhannenteen", "kymmenennellätuhannennella", "kymmenenneltätuhannennelta", "kymmenennelletuhannennelle", "kymmenentenätuhannentena", "kymmenenneksituhannenneksi", "kymmenensintuhannensin", "kymmenennettätuhannennetta", "kymmenensinetuhannensine" ) ) self.assertEqual( tuple(n2f(10000, to="ordinal", case=c, plural=True) for c in CASES), ( "kymmenennettuhannennet", "kymmenensientuhannensien", "kymmenensiätuhannensia", "kymmenensissätuhannensissa", "kymmenensistätuhannensista", "kymmenensiintuhannensiin", "kymmenensillätuhannensilla", "kymmenensiltätuhannensilta", "kymmenensilletuhannensille", "kymmenensinätuhannensina", "kymmenensiksituhannensiksi", "kymmenensintuhannensin", "kymmenensittätuhannensitta", "kymmenensinetuhannensine" ) ) # twelve thousand, three hundred and forty-five self.assertEqual( tuple(n2f(12345, to="ordinal", case=c) for c in CASES), ( "kahdestoistatuhannes " "kolmassadasneljäskymmenesviides", "kahdennentoistatuhannennen " "kolmannensadannenneljännenkymmenennenviidennen", "kahdettatoistatuhannetta " "kolmattasadattaneljättäkymmenettäviidettä", "kahdennessatoistatuhannennessa " "kolmannessasadannessaneljännessäkymmenennessäviidennessä", "kahdennestatoistatuhannennesta " "kolmannestasadannestaneljännestäkymmenennestäviidennestä", "kahdenteentoistatuhannenteen " "kolmanteensadanteenneljänteenkymmenenteenviidenteen", "kahdennellatoistatuhannennella " "kolmannellasadannellaneljännelläkymmenennelläviidennellä", "kahdenneltatoistatuhannennelta " "kolmanneltasadanneltaneljänneltäkymmenenneltäviidenneltä", "kahdennelletoistatuhannennelle " "kolmannellesadannelleneljännellekymmenennelleviidennelle", "kahdentenatoistatuhannentena " "kolmantenasadantenaneljäntenäkymmenentenäviidentenä", "kahdenneksitoistatuhannenneksi " "kolmanneksisadanneksineljänneksikymmenenneksiviidenneksi", "kahdensintoistatuhannensin " "kolmansinsadansinneljänsinkymmenensinviidensin", "kahdennettatoistatuhannennetta " "kolmannettasadannettaneljännettäkymmenennettäviidennettä", "kahdensinetoistatuhannensine " "kolmansinesadansineneljänsinekymmenensineviidensine" ) ) self.assertEqual( tuple(n2f(12345, to="ordinal", case=c, plural=True) for c in CASES), ( "kahdennettoistatuhannennet " "kolmannetsadannetneljännetkymmenennetviidennet", "kahdensientoistatuhannensien " "kolmansiensadansienneljänsienkymmenensienviidensien", "kahdensiatoistatuhannensia " "kolmansiasadansianeljänsiäkymmenensiäviidensiä", "kahdensissatoistatuhannensissa " "kolmansissasadansissaneljänsissäkymmenensissäviidensissä", "kahdensistatoistatuhannensista " "kolmansistasadansistaneljänsistäkymmenensistäviidensistä", "kahdensiintoistatuhannensiin " "kolmansiinsadansiinneljänsiinkymmenensiinviidensiin", "kahdensillatoistatuhannensilla " "kolmansillasadansillaneljänsilläkymmenensilläviidensillä", "kahdensiltatoistatuhannensilta " "kolmansiltasadansiltaneljänsiltäkymmenensiltäviidensiltä", "kahdensilletoistatuhannensille " "kolmansillesadansilleneljänsillekymmenensilleviidensille", "kahdensinatoistatuhannensina " "kolmansinasadansinaneljänsinäkymmenensinäviidensinä", "kahdensiksitoistatuhannensiksi " "kolmansiksisadansiksineljänsiksikymmenensiksiviidensiksi", "kahdensintoistatuhannensin " "kolmansinsadansinneljänsinkymmenensinviidensin", "kahdensittatoistatuhannensitta " "kolmansittasadansittaneljänsittäkymmenensittäviidensittä", "kahdensinetoistatuhannensine " "kolmansinesadansineneljänsinekymmenensineviidensine" ) ) # one hundred thousand self.assertEqual( tuple(n2f(100000, to="ordinal", case=c) for c in CASES), ( "sadastuhannes", "sadannentuhannennen", "sadattatuhannetta", "sadannessatuhannennessa", "sadannestatuhannennesta", "sadanteentuhannenteen", "sadannellatuhannennella", "sadanneltatuhannennelta", "sadannelletuhannennelle", "sadantenatuhannentena", "sadanneksituhannenneksi", "sadansintuhannensin", "sadannettatuhannennetta", "sadansinetuhannensine" ) ) self.assertEqual( tuple(n2f(100000, to="ordinal", case=c, plural=True) for c in CASES), ( "sadannettuhannennet", "sadansientuhannensien", "sadansiatuhannensia", "sadansissatuhannensissa", "sadansistatuhannensista", "sadansiintuhannensiin", "sadansillatuhannensilla", "sadansiltatuhannensilta", "sadansilletuhannensille", "sadansinatuhannensina", "sadansiksituhannensiksi", "sadansintuhannensin", "sadansittatuhannensitta", "sadansinetuhannensine" ) ) # one hundred and twenty-three thousand, four hundred and fifty-six self.assertEqual( tuple(n2f(123456, to="ordinal", case=c) for c in CASES), ( "sadaskahdeskymmeneskolmastuhannes " "neljässadasviideskymmeneskuudes", "sadannenkahdennenkymmenennenkolmannentuhannennen " "neljännensadannenviidennenkymmenennenkuudennen", "sadattakahdettakymmenettäkolmattatuhannetta " "neljättäsadattaviidettäkymmenettäkuudetta", "sadannessakahdennessakymmenennessäkolmannessatuhannennessa " "neljännessäsadannessaviidennessäkymmenennessäkuudennessa", "sadannestakahdennestakymmenennestäkolmannestatuhannennesta " "neljännestäsadannestaviidennestäkymmenennestäkuudennesta", "sadanteenkahdenteenkymmenenteenkolmanteentuhannenteen " "neljänteensadanteenviidenteenkymmenenteenkuudenteen", "sadannellakahdennellakymmenennelläkolmannellatuhannennella " "neljännelläsadannellaviidennelläkymmenennelläkuudennella", "sadanneltakahdenneltakymmenenneltäkolmanneltatuhannennelta " "neljänneltäsadanneltaviidenneltäkymmenenneltäkuudennelta", "sadannellekahdennellekymmenennellekolmannelletuhannennelle " "neljännellesadannelleviidennellekymmenennellekuudennelle", "sadantenakahdentenakymmenentenäkolmantenatuhannentena " "neljäntenäsadantenaviidentenäkymmenentenäkuudentena", "sadanneksikahdenneksikymmenenneksikolmanneksituhannenneksi " "neljänneksisadanneksiviidenneksikymmenenneksikuudenneksi", "sadansinkahdensinkymmenensinkolmansintuhannensin " "neljänsinsadansinviidensinkymmenensinkuudensin", "sadannettakahdennettakymmenennettäkolmannettatuhannennetta " "neljännettäsadannettaviidennettäkymmenennettäkuudennetta", "sadansinekahdensinekymmenensinekolmansinetuhannensine " "neljänsinesadansineviidensinekymmenensinekuudensine" ) ) self.assertEqual( tuple(n2f(123456, to="ordinal", case=c, plural=True) for c in CASES), ( "sadannetkahdennetkymmenennetkolmannettuhannennet " "neljännetsadannetviidennetkymmenennetkuudennet", "sadansienkahdensienkymmenensienkolmansientuhannensien " "neljänsiensadansienviidensienkymmenensienkuudensien", "sadansiakahdensiakymmenensiäkolmansiatuhannensia " "neljänsiäsadansiaviidensiäkymmenensiäkuudensia", "sadansissakahdensissakymmenensissäkolmansissatuhannensissa " "neljänsissäsadansissaviidensissäkymmenensissäkuudensissa", "sadansistakahdensistakymmenensistäkolmansistatuhannensista " "neljänsistäsadansistaviidensistäkymmenensistäkuudensista", "sadansiinkahdensiinkymmenensiinkolmansiintuhannensiin " "neljänsiinsadansiinviidensiinkymmenensiinkuudensiin", "sadansillakahdensillakymmenensilläkolmansillatuhannensilla " "neljänsilläsadansillaviidensilläkymmenensilläkuudensilla", "sadansiltakahdensiltakymmenensiltäkolmansiltatuhannensilta " "neljänsiltäsadansiltaviidensiltäkymmenensiltäkuudensilta", "sadansillekahdensillekymmenensillekolmansilletuhannensille " "neljänsillesadansilleviidensillekymmenensillekuudensille", "sadansinakahdensinakymmenensinäkolmansinatuhannensina " "neljänsinäsadansinaviidensinäkymmenensinäkuudensina", "sadansiksikahdensiksikymmenensiksikolmansiksituhannensiksi " "neljänsiksisadansiksiviidensiksikymmenensiksikuudensiksi", "sadansinkahdensinkymmenensinkolmansintuhannensin " "neljänsinsadansinviidensinkymmenensinkuudensin", "sadansittakahdensittakymmenensittäkolmansittatuhannensitta " "neljänsittäsadansittaviidensittäkymmenensittäkuudensitta", "sadansinekahdensinekymmenensinekolmansinetuhannensine " "neljänsinesadansineviidensinekymmenensinekuudensine" ) ) # one million self.assertEqual( tuple(n2f(10**6, to="ordinal", case=c) for c in CASES), ("miljoonas", "miljoonannen", "miljoonatta", "miljoonannessa", "miljoonannesta", "miljoonanteen", "miljoonannella", "miljoonannelta", "miljoonannelle", "miljoonantena", "miljoonanneksi", "miljoonansin", "miljoonannetta", "miljoonansine") ) self.assertEqual( tuple(n2f(10**6, to="ordinal", case=c, plural=True) for c in CASES), ("miljoonannet", "miljoonansien", "miljoonansia", "miljoonansissa", "miljoonansista", "miljoonansiin", "miljoonansilla", "miljoonansilta", "miljoonansille", "miljoonansina", "miljoonansiksi", "miljoonansin", "miljoonansitta", "miljoonansine") ) # one million, two hundred and thirty-four thousand, # five hundred and sixty-seven self.assertEqual( tuple(n2f(1234567, to="ordinal", case=c) for c in CASES), ( "miljoonas " "kahdessadaskolmaskymmenesneljäs" "tuhannes " "viidessadaskuudeskymmenesseitsemäs", "miljoonannen " "kahdennensadannenkolmannenkymmenennenneljännen" "tuhannennen " "viidennensadannenkuudennenkymmenennenseitsemännen", "miljoonatta " "kahdettasadattakolmattakymmenettäneljättä" "tuhannetta " "viidettäsadattakuudettakymmenettäseitsemättä", "miljoonannessa " "kahdennessasadannessakolmannessakymmenennessäneljännessä" "tuhannennessa " "viidennessäsadannessakuudennessakymmenennessäseitsemännessä", "miljoonannesta " "kahdennestasadannestakolmannestakymmenennestäneljännestä" "tuhannennesta " "viidennestäsadannestakuudennestakymmenennestäseitsemännestä", "miljoonanteen " "kahdenteensadanteenkolmanteenkymmenenteenneljänteen" "tuhannenteen " "viidenteensadanteenkuudenteenkymmenenteenseitsemänteen", "miljoonannella " "kahdennellasadannellakolmannellakymmenennelläneljännellä" "tuhannennella " "viidennelläsadannellakuudennellakymmenennelläseitsemännellä", "miljoonannelta " "kahdenneltasadanneltakolmanneltakymmenenneltäneljänneltä" "tuhannennelta " "viidenneltäsadanneltakuudenneltakymmenenneltäseitsemänneltä", "miljoonannelle " "kahdennellesadannellekolmannellekymmenennelleneljännelle" "tuhannennelle " "viidennellesadannellekuudennellekymmenennelleseitsemännelle", "miljoonantena " "kahdentenasadantenakolmantenakymmenentenäneljäntenä" "tuhannentena " "viidentenäsadantenakuudentenakymmenentenäseitsemäntenä", "miljoonanneksi " "kahdenneksisadanneksikolmanneksikymmenenneksineljänneksi" "tuhannenneksi " "viidenneksisadanneksikuudenneksikymmenenneksiseitsemänneksi", "miljoonansin " "kahdensinsadansinkolmansinkymmenensinneljänsin" "tuhannensin " "viidensinsadansinkuudensinkymmenensinseitsemänsin", "miljoonannetta " "kahdennettasadannettakolmannettakymmenennettäneljännettä" "tuhannennetta " "viidennettäsadannettakuudennettakymmenennettäseitsemännettä", "miljoonansine " "kahdensinesadansinekolmansinekymmenensineneljänsine" "tuhannensine " "viidensinesadansinekuudensinekymmenensineseitsemänsine" ) ) self.assertEqual( tuple(n2f(1234567, to="ordinal", case=c, plural=True) for c in CASES), ( "miljoonannet " "kahdennetsadannetkolmannetkymmenennetneljännet" "tuhannennet " "viidennetsadannetkuudennetkymmenennetseitsemännet", "miljoonansien " "kahdensiensadansienkolmansienkymmenensienneljänsien" "tuhannensien " "viidensiensadansienkuudensienkymmenensienseitsemänsien", "miljoonansia " "kahdensiasadansiakolmansiakymmenensiäneljänsiä" "tuhannensia " "viidensiäsadansiakuudensiakymmenensiäseitsemänsiä", "miljoonansissa " "kahdensissasadansissakolmansissakymmenensissäneljänsissä" "tuhannensissa " "viidensissäsadansissakuudensissakymmenensissäseitsemänsissä", "miljoonansista " "kahdensistasadansistakolmansistakymmenensistäneljänsistä" "tuhannensista " "viidensistäsadansistakuudensistakymmenensistäseitsemänsistä", "miljoonansiin " "kahdensiinsadansiinkolmansiinkymmenensiinneljänsiin" "tuhannensiin " "viidensiinsadansiinkuudensiinkymmenensiinseitsemänsiin", "miljoonansilla " "kahdensillasadansillakolmansillakymmenensilläneljänsillä" "tuhannensilla " "viidensilläsadansillakuudensillakymmenensilläseitsemänsillä", "miljoonansilta " "kahdensiltasadansiltakolmansiltakymmenensiltäneljänsiltä" "tuhannensilta " "viidensiltäsadansiltakuudensiltakymmenensiltäseitsemänsiltä", "miljoonansille " "kahdensillesadansillekolmansillekymmenensilleneljänsille" "tuhannensille " "viidensillesadansillekuudensillekymmenensilleseitsemänsille", "miljoonansina " "kahdensinasadansinakolmansinakymmenensinäneljänsinä" "tuhannensina " "viidensinäsadansinakuudensinakymmenensinäseitsemänsinä", "miljoonansiksi " "kahdensiksisadansiksikolmansiksikymmenensiksineljänsiksi" "tuhannensiksi " "viidensiksisadansiksikuudensiksikymmenensiksiseitsemänsiksi", "miljoonansin " "kahdensinsadansinkolmansinkymmenensinneljänsin" "tuhannensin " "viidensinsadansinkuudensinkymmenensinseitsemänsin", "miljoonansitta " "kahdensittasadansittakolmansittakymmenensittäneljänsittä" "tuhannensitta " "viidensittäsadansittakuudensittakymmenensittäseitsemänsittä", "miljoonansine " "kahdensinesadansinekolmansinekymmenensineneljänsine" "tuhannensine " "viidensinesadansinekuudensinekymmenensineseitsemänsine" ) ) # one billion (short scale) self.assertEqual( tuple(n2f(10**9, to="ordinal", case=c) for c in CASES), ("miljardis", "miljardinnen", "miljarditta", "miljardinnessa", "miljardinnesta", "miljardinteen", "miljardinnella", "miljardinnelta", "miljardinnelle", "miljardintena", "miljardinneksi", "miljardinsin", "miljardinnetta", "miljardinsine") ) self.assertEqual( tuple(n2f(10**9, to="ordinal", case=c, plural=True) for c in CASES), ("miljardinnet", "miljardinsien", "miljardinsia", "miljardinsissa", "miljardinsista", "miljardinsiin", "miljardinsilla", "miljardinsilta", "miljardinsille", "miljardinsina", "miljardinsiksi", "miljardinsin", "miljardinsitta", "miljardinsine") ) # one billion, two hundred and thirty-four million, # five hundred and sixty-seven thousand, eight hundred and ninety # (short scale) self.assertEqual( tuple(n2f(1234567890, to="ordinal", case=c) for c in CASES), ( "miljardis " "kahdessadaskolmaskymmenesneljäs" "miljoonas " "viidessadaskuudeskymmenesseitsemäs" "tuhannes " "kahdeksassadasyhdeksäskymmenes", "miljardinnen " "kahdennensadannenkolmannenkymmenennenneljännen" "miljoonannen " "viidennensadannenkuudennenkymmenennenseitsemännen" "tuhannennen " "kahdeksannensadannenyhdeksännenkymmenennen", "miljarditta " "kahdettasadattakolmattakymmenettäneljättä" "miljoonatta " "viidettäsadattakuudettakymmenettäseitsemättä" "tuhannetta " "kahdeksattasadattayhdeksättäkymmenettä", "miljardinnessa " "kahdennessasadannessakolmannessakymmenennessäneljännessä" "miljoonannessa " "viidennessäsadannessakuudennessakymmenennessäseitsemännessä" "tuhannennessa " "kahdeksannessasadannessayhdeksännessäkymmenennessä", "miljardinnesta " "kahdennestasadannestakolmannestakymmenennestäneljännestä" "miljoonannesta " "viidennestäsadannestakuudennestakymmenennestäseitsemännestä" "tuhannennesta " "kahdeksannestasadannestayhdeksännestäkymmenennestä", "miljardinteen " "kahdenteensadanteenkolmanteenkymmenenteenneljänteen" "miljoonanteen " "viidenteensadanteenkuudenteenkymmenenteenseitsemänteen" "tuhannenteen " "kahdeksanteensadanteenyhdeksänteenkymmenenteen", "miljardinnella " "kahdennellasadannellakolmannellakymmenennelläneljännellä" "miljoonannella " "viidennelläsadannellakuudennellakymmenennelläseitsemännellä" "tuhannennella " "kahdeksannellasadannellayhdeksännelläkymmenennellä", "miljardinnelta " "kahdenneltasadanneltakolmanneltakymmenenneltäneljänneltä" "miljoonannelta " "viidenneltäsadanneltakuudenneltakymmenenneltäseitsemänneltä" "tuhannennelta " "kahdeksanneltasadanneltayhdeksänneltäkymmenenneltä", "miljardinnelle " "kahdennellesadannellekolmannellekymmenennelleneljännelle" "miljoonannelle " "viidennellesadannellekuudennellekymmenennelleseitsemännelle" "tuhannennelle " "kahdeksannellesadannelleyhdeksännellekymmenennelle", "miljardintena " "kahdentenasadantenakolmantenakymmenentenäneljäntenä" "miljoonantena " "viidentenäsadantenakuudentenakymmenentenäseitsemäntenä" "tuhannentena " "kahdeksantenasadantenayhdeksäntenäkymmenentenä", "miljardinneksi " "kahdenneksisadanneksikolmanneksikymmenenneksineljänneksi" "miljoonanneksi " "viidenneksisadanneksikuudenneksikymmenenneksiseitsemänneksi" "tuhannenneksi " "kahdeksanneksisadanneksiyhdeksänneksikymmenenneksi", "miljardinsin " "kahdensinsadansinkolmansinkymmenensinneljänsin" "miljoonansin " "viidensinsadansinkuudensinkymmenensinseitsemänsin" "tuhannensin " "kahdeksansinsadansinyhdeksänsinkymmenensin", "miljardinnetta " "kahdennettasadannettakolmannettakymmenennettäneljännettä" "miljoonannetta " "viidennettäsadannettakuudennettakymmenennettäseitsemännettä" "tuhannennetta " "kahdeksannettasadannettayhdeksännettäkymmenennettä", "miljardinsine " "kahdensinesadansinekolmansinekymmenensineneljänsine" "miljoonansine " "viidensinesadansinekuudensinekymmenensineseitsemänsine" "tuhannensine " "kahdeksansinesadansineyhdeksänsinekymmenensine" ) ) self.assertEqual( tuple(n2f(1234567890, to="ordinal", case=c, plural=True) for c in CASES), ( "miljardinnet " "kahdennetsadannetkolmannetkymmenennetneljännet" "miljoonannet " "viidennetsadannetkuudennetkymmenennetseitsemännet" "tuhannennet " "kahdeksannetsadannetyhdeksännetkymmenennet", "miljardinsien " "kahdensiensadansienkolmansienkymmenensienneljänsien" "miljoonansien " "viidensiensadansienkuudensienkymmenensienseitsemänsien" "tuhannensien " "kahdeksansiensadansienyhdeksänsienkymmenensien", "miljardinsia " "kahdensiasadansiakolmansiakymmenensiäneljänsiä" "miljoonansia " "viidensiäsadansiakuudensiakymmenensiäseitsemänsiä" "tuhannensia " "kahdeksansiasadansiayhdeksänsiäkymmenensiä", "miljardinsissa " "kahdensissasadansissakolmansissakymmenensissäneljänsissä" "miljoonansissa " "viidensissäsadansissakuudensissakymmenensissäseitsemänsissä" "tuhannensissa " "kahdeksansissasadansissayhdeksänsissäkymmenensissä", "miljardinsista " "kahdensistasadansistakolmansistakymmenensistäneljänsistä" "miljoonansista " "viidensistäsadansistakuudensistakymmenensistäseitsemänsistä" "tuhannensista " "kahdeksansistasadansistayhdeksänsistäkymmenensistä", "miljardinsiin " "kahdensiinsadansiinkolmansiinkymmenensiinneljänsiin" "miljoonansiin " "viidensiinsadansiinkuudensiinkymmenensiinseitsemänsiin" "tuhannensiin " "kahdeksansiinsadansiinyhdeksänsiinkymmenensiin", "miljardinsilla " "kahdensillasadansillakolmansillakymmenensilläneljänsillä" "miljoonansilla " "viidensilläsadansillakuudensillakymmenensilläseitsemänsillä" "tuhannensilla " "kahdeksansillasadansillayhdeksänsilläkymmenensillä", "miljardinsilta " "kahdensiltasadansiltakolmansiltakymmenensiltäneljänsiltä" "miljoonansilta " "viidensiltäsadansiltakuudensiltakymmenensiltäseitsemänsiltä" "tuhannensilta " "kahdeksansiltasadansiltayhdeksänsiltäkymmenensiltä", "miljardinsille " "kahdensillesadansillekolmansillekymmenensilleneljänsille" "miljoonansille " "viidensillesadansillekuudensillekymmenensilleseitsemänsille" "tuhannensille " "kahdeksansillesadansilleyhdeksänsillekymmenensille", "miljardinsina " "kahdensinasadansinakolmansinakymmenensinäneljänsinä" "miljoonansina " "viidensinäsadansinakuudensinakymmenensinäseitsemänsinä" "tuhannensina " "kahdeksansinasadansinayhdeksänsinäkymmenensinä", "miljardinsiksi " "kahdensiksisadansiksikolmansiksikymmenensiksineljänsiksi" "miljoonansiksi " "viidensiksisadansiksikuudensiksikymmenensiksiseitsemänsiksi" "tuhannensiksi " "kahdeksansiksisadansiksiyhdeksänsiksikymmenensiksi", "miljardinsin " "kahdensinsadansinkolmansinkymmenensinneljänsin" "miljoonansin " "viidensinsadansinkuudensinkymmenensinseitsemänsin" "tuhannensin " "kahdeksansinsadansinyhdeksänsinkymmenensin", "miljardinsitta " "kahdensittasadansittakolmansittakymmenensittäneljänsittä" "miljoonansitta " "viidensittäsadansittakuudensittakymmenensittäseitsemänsittä" "tuhannensitta " "kahdeksansittasadansittayhdeksänsittäkymmenensittä", "miljardinsine " "kahdensinesadansinekolmansinekymmenensineneljänsine" "miljoonansine " "viidensinesadansinekuudensinekymmenensineseitsemänsine" "tuhannensine " "kahdeksansinesadansineyhdeksänsinekymmenensine" ) ) # one trillion (short scale) self.assertEqual( tuple(n2f((10**6)**2, to="ordinal", case=c) for c in CASES), ("biljoonas", "biljoonannen", "biljoonatta", "biljoonannessa", "biljoonannesta", "biljoonanteen", "biljoonannella", "biljoonannelta", "biljoonannelle", "biljoonantena", "biljoonanneksi", "biljoonansin", "biljoonannetta", "biljoonansine") ) self.assertEqual( tuple(n2f((10**6)**2, to="ordinal", case=c, plural=True) for c in CASES), ("biljoonannet", "biljoonansien", "biljoonansia", "biljoonansissa", "biljoonansista", "biljoonansiin", "biljoonansilla", "biljoonansilta", "biljoonansille", "biljoonansina", "biljoonansiksi", "biljoonansin", "biljoonansitta", "biljoonansine") ) # one quintillion (short scale) self.assertEqual( tuple(n2f((10**6)**3, to="ordinal", case=c) for c in CASES), ("triljoonas", "triljoonannen", "triljoonatta", "triljoonannessa", "triljoonannesta", "triljoonanteen", "triljoonannella", "triljoonannelta", "triljoonannelle", "triljoonantena", "triljoonanneksi", "triljoonansin", "triljoonannetta", "triljoonansine") ) self.assertEqual( tuple(n2f((10**6)**3, to="ordinal", case=c, plural=True) for c in CASES), ("triljoonannet", "triljoonansien", "triljoonansia", "triljoonansissa", "triljoonansista", "triljoonansiin", "triljoonansilla", "triljoonansilta", "triljoonansille", "triljoonansina", "triljoonansiksi", "triljoonansin", "triljoonansitta", "triljoonansine") ) def test_negative(self): self.assertEqual(n2f(-1, to="cardinal"), "miinus yksi") with self.assertRaises(TypeError): n2f(-1, to="ordinal") def test_cardinal_float(self): self.assertEqual(n2f(1.5, to="cardinal"), "yksi pilkku viisi") with self.assertRaises(NotImplementedError): n2f(1.5, to="cardinal", case="inessive") def test_ordinal_num(self): with self.assertRaises(NotImplementedError): n2f(1, to="ordinal_num") def test_year(self): self.assertEqual(n2f(2018, to="year"), "kaksituhattakahdeksantoista") self.assertEqual( n2f(-99, to="year"), "yhdeksänkymmentäyhdeksän ennen ajanlaskun alkua") def test_currency(self): self.assertEqual( n2f(150, to="currency"), "yksi euro ja viisikymmentä senttiä") self.assertEqual( n2f(150, to="currency", currency="FIM", adjective=True), "yksi Suomen markka ja viisikymmentä penniä") num2words-0.5.14/tests/test_fr.py000066400000000000000000000157161473005321200167320ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (1, 'un'), (2, 'deux'), (3, 'trois'), (5.5, 'cinq virgule cinq'), (11, 'onze'), (12, 'douze'), (16, 'seize'), (17.42, 'dix-sept virgule quatre deux'), (19, 'dix-neuf'), (20, 'vingt'), (21, 'vingt et un'), (26, 'vingt-six'), (27.312, 'vingt-sept virgule trois un deux'), (28, 'vingt-huit'), (30, 'trente'), (31, 'trente et un'), (40, 'quarante'), (44, 'quarante-quatre'), (50, 'cinquante'), (53.486, 'cinquante-trois virgule quatre huit six'), (55, 'cinquante-cinq'), (60, 'soixante'), (67, 'soixante-sept'), (70, 'soixante-dix'), (79, 'soixante-dix-neuf'), (89, 'quatre-vingt-neuf'), (95, 'quatre-vingt-quinze'), (100, 'cent'), (101, 'cent un'), (199, 'cent quatre-vingt-dix-neuf'), (203, 'deux cent trois'), (287, 'deux cent quatre-vingt-sept'), (300.42, 'trois cents virgule quatre deux'), (356, 'trois cent cinquante-six'), (400, 'quatre cents'), (434, 'quatre cent trente-quatre'), (578, 'cinq cent soixante-dix-huit'), (689, 'six cent quatre-vingt-neuf'), (729, 'sept cent vingt-neuf'), (894, 'huit cent quatre-vingt-quatorze'), (999, 'neuf cent quatre-vingt-dix-neuf'), (1000, 'mille'), (1001, 'mille un'), (1097, 'mille quatre-vingt-dix-sept'), (1104, 'mille cent quatre'), (1243, 'mille deux cent quarante-trois'), (2385, 'deux mille trois cent quatre-vingt-cinq'), (3766, 'trois mille sept cent soixante-six'), (4196, 'quatre mille cent quatre-vingt-seize'), (4196.42, 'quatre mille cent quatre-vingt-seize virgule quatre deux'), (5846, 'cinq mille huit cent quarante-six'), (6459, 'six mille quatre cent cinquante-neuf'), (7232, 'sept mille deux cent trente-deux'), (8569, 'huit mille cinq cent soixante-neuf'), (9539, 'neuf mille cinq cent trente-neuf'), (1000000, 'un million'), (1000001, 'un million un'), (4000000, 'quatre millions'), (4000004, 'quatre millions quatre'), (4300000, 'quatre millions trois cent mille'), (80000000, 'quatre-vingts millions'), (300000000, 'trois cents millions'), (10000000000000, 'dix billions'), (10000000000010, 'dix billions dix'), (100000000000000, 'cent billions'), (1000000000000000000, 'un trillion'), (1000000000000000000000, 'un trilliard'), (10000000000000000000000000, 'dix quadrillions') ) TEST_CASES_ORDINAL = ( (1, 'premier'), (8, 'huitième'), (12, 'douzième'), (14, 'quatorzième'), (28, 'vingt-huitième'), (100, 'centième'), (1000, 'millième'), (1000000, 'un millionième'), (1000000000000000, 'un billiardième'), (1000000000000000000, 'un trillionième') # over 1e18 is not supported ) TEST_CASES_ORDINAL_NUM = ( (1, '1er'), (8, '8me'), (11, '11me'), (12, '12me'), (14, '14me'), (21, '21me'), (28, '28me'), (100, '100me'), (101, '101me'), (1000, '1000me'), (1000000, '1000000me') ) TEST_CASES_TO_CURRENCY_EUR = ( (1.00, 'un euro et zéro centimes'), (2.01, 'deux euros et un centime'), (8.10, 'huit euros et dix centimes'), (12.26, 'douze euros et vingt-six centimes'), (21.29, 'vingt et un euros et vingt-neuf centimes'), (81.25, 'quatre-vingt-un euros et vingt-cinq centimes'), (100.00, 'cent euros et zéro centimes'), ) TEST_CASES_TO_CURRENCY_FRF = ( (1.00, 'un franc et zéro centimes'), (2.01, 'deux francs et un centime'), (8.10, 'huit francs et dix centimes'), (12.27, 'douze francs et vingt-sept centimes'), (21.29, 'vingt et un francs et vingt-neuf centimes'), (81.25, 'quatre-vingt-un francs et vingt-cinq centimes'), (100.00, 'cent francs et zéro centimes'), ) TEST_CASES_TO_CURRENCY_USD = ( (1.00, 'un dollar et zéro cents'), (2.01, 'deux dollars et un cent'), (8.10, 'huit dollars et dix cents'), (12.26, 'douze dollars et vingt-six cents'), (21.29, 'vingt et un dollars et vingt-neuf cents'), (81.25, 'quatre-vingt-un dollars et vingt-cinq cents'), (100.00, 'cent dollars et zéro cents'), ) class Num2WordsFRTest(TestCase): def test_ordinal_special_joins(self): # ref https://github.com/savoirfairelinux/num2words/issues/18 self.assertEqual( num2words(5, ordinal=True, lang='fr'), "cinquième" ) self.assertEqual( num2words(35, ordinal=True, lang='fr'), "trente-cinquième" ) self.assertEqual( num2words(9, ordinal=True, lang='fr'), "neuvième" ) self.assertEqual( num2words(49, ordinal=True, lang='fr'), "quarante-neuvième" ) def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='fr'), test[1]) def test_ordinal(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='fr', ordinal=True), test[1] ) def test_ordinal_num(self): for test in TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='fr', to='ordinal_num'), test[1] ) def test_currency_eur(self): for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang='fr', to='currency', currency='EUR'), test[1] ) def test_currency_frf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='fr', to='currency', currency='FRF'), test[1] ) def test_currency_usd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='fr', to='currency', currency='USD'), test[1] ) def test_max_numbers(self): with self.assertRaises(OverflowError) as context: num2words(10 ** 700, lang='fr') self.assertTrue('trop grand' in str(context.exception)) num2words-0.5.14/tests/test_fr_be.py000066400000000000000000000110761473005321200173730ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (70, 'septante'), (79, 'septante-neuf'), (89, 'quatre-vingt-neuf'), (95, 'nonante-cinq'), (729, 'sept cents vingt-neuf'), (894, 'huit cents nonante-quatre'), (999, 'neuf cents nonante-neuf'), (7232, 'sept mille deux cents trente-deux'), (8569, 'huit mille cinq cents soixante-neuf'), (9539, 'neuf mille cinq cents trente-neuf'), (1000000, 'un millions'), (1000001, 'un millions un'), (4000000, 'quatre millions'), (10000000000000, 'dix billions'), (100000000000000, 'cent billions'), (1000000000000000000, 'un trillions'), (1000000000000000000000, 'un trilliards'), (10000000000000000000000000, 'dix quadrillions') ) TEST_CASES_ORDINAL = ( (1, 'premier'), (8, 'huitième'), (12, 'douzième'), (14, 'quatorzième'), (28, 'vingt-huitième'), (100, 'centième'), (1000, 'millième'), (1000000, 'un millionsième'), (1000000000000000, 'un billiardsième'), (1000000000000000000, 'un trillionsième') # over 1e18 is not supported ) TEST_CASES_TO_CURRENCY_EUR = ( (1.00, 'un euro et zéro centimes'), (2.01, 'deux euros et un centime'), (8.10, 'huit euros et dix centimes'), (12.26, 'douze euros et vingt-six centimes'), (21.29, 'vingt et un euros et vingt-neuf centimes'), (81.25, 'quatre-vingt et un euros et vingt-cinq centimes'), (100.00, 'cent euros et zéro centimes'), ) TEST_CASES_TO_CURRENCY_FRF = ( (1.00, 'un franc et zéro centimes'), (2.01, 'deux francs et un centime'), (8.10, 'huit francs et dix centimes'), (12.27, 'douze francs et vingt-sept centimes'), (21.29, 'vingt et un francs et vingt-neuf centimes'), (81.25, 'quatre-vingt et un francs et vingt-cinq centimes'), (100.00, 'cent francs et zéro centimes'), ) # Lang to execute current test LANG = 'fr_BE' class Num2WordsENTest(TestCase): def test_ordinal_special_joins(self): self.assertEqual( num2words(5, ordinal=True, lang=LANG), "cinquième" ) self.assertEqual( num2words(6, ordinal=True, lang=LANG), "sixième" ) self.assertEqual( num2words(35, ordinal=True, lang=LANG), "trente-cinquième" ) self.assertEqual(num2words(9, ordinal=True, lang=LANG), "neuvième") self.assertEqual( num2words(49, ordinal=True, lang=LANG), "quarante-neuvième" ) self.assertEqual(num2words(71, lang=LANG), "septante et un") self.assertEqual(num2words(81, lang=LANG), "quatre-vingt et un") self.assertEqual(num2words(80, lang=LANG), "quatre-vingt") self.assertEqual( num2words(880, lang=LANG), "huit cents quatre-vingt") self.assertEqual( num2words(91, ordinal=True, lang=LANG), "nonante et unième" ) self.assertEqual(num2words(53, lang=LANG), "cinquante-trois") def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang=LANG), test[1]) def test_ordinal(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang=LANG, ordinal=True), test[1] ) def test_currency_eur(self): for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang=LANG, to='currency'), test[1] ) def test_currency_frf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang=LANG, to='currency', currency='FRF'), test[1] ) num2words-0.5.14/tests/test_fr_ch.py000066400000000000000000000110621473005321200173720ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (70, 'septante'), (79, 'septante-neuf'), (89, 'huitante-neuf'), (95, 'nonante-cinq'), (729, 'sept cents vingt-neuf'), (894, 'huit cents nonante-quatre'), (999, 'neuf cents nonante-neuf'), (7232, 'sept mille deux cents trente-deux'), (8569, 'huit mille cinq cents soixante-neuf'), (9539, 'neuf mille cinq cents trente-neuf'), (1000000, 'un millions'), (1000001, 'un millions un'), (4000000, 'quatre millions'), (10000000000000, 'dix billions'), (100000000000000, 'cent billions'), (1000000000000000000, 'un trillions'), (1000000000000000000000, 'un trilliards'), (10000000000000000000000000, 'dix quadrillions') ) TEST_CASES_ORDINAL = ( (1, 'premier'), (8, 'huitième'), (12, 'douzième'), (14, 'quatorzième'), (28, 'vingt-huitième'), (100, 'centième'), (1000, 'millième'), (1000000, 'un millionsième'), (1000000000000000, 'un billiardsième'), (1000000000000000000, 'un trillionsième') # over 1e18 is not supported ) TEST_CASES_TO_CURRENCY_EUR = ( (1.00, 'un euro et zéro centimes'), (2.01, 'deux euros et un centime'), (8.10, 'huit euros et dix centimes'), (12.26, 'douze euros et vingt-six centimes'), (21.29, 'vingt et un euros et vingt-neuf centimes'), (81.25, 'huitante et un euros et vingt-cinq centimes'), (100.00, 'cent euros et zéro centimes'), ) TEST_CASES_TO_CURRENCY_FRF = ( (1.00, 'un franc et zéro centimes'), (2.01, 'deux francs et un centime'), (8.10, 'huit francs et dix centimes'), (12.27, 'douze francs et vingt-sept centimes'), (21.29, 'vingt et un francs et vingt-neuf centimes'), (81.25, 'huitante et un francs et vingt-cinq centimes'), (100.00, 'cent francs et zéro centimes'), ) class Num2WordsENTest(TestCase): def test_ordinal_special_joins(self): self.assertEqual( num2words(5, ordinal=True, lang='fr_CH'), "cinquième" ) self.assertEqual( num2words(6, ordinal=True, lang='fr_CH'), "sixième" ) self.assertEqual( num2words(35, ordinal=True, lang='fr_CH'), "trente-cinquième" ) self.assertEqual(num2words(9, ordinal=True, lang='fr_CH'), "neuvième") self.assertEqual( num2words(49, ordinal=True, lang='fr_CH'), "quarante-neuvième" ) self.assertEqual(num2words(71, lang='fr_CH'), "septante et un") self.assertEqual(num2words(81, lang='fr_CH'), "huitante et un") self.assertEqual(num2words(80, lang='fr_CH'), "huitante") self.assertEqual(num2words(880, lang='fr_CH'), "huit cents huitante") self.assertEqual( num2words(91, ordinal=True, lang='fr_CH'), "nonante et unième" ) self.assertEqual(num2words(53, lang='fr_CH'), "cinquante-trois") def test_number(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='fr_CH'), test[1]) def test_ordinal(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='fr_CH', ordinal=True), test[1] ) def test_currency_eur(self): for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang='fr_CH', to='currency'), test[1] ) def test_currency_frf(self): for test in TEST_CASES_TO_CURRENCY_FRF: self.assertEqual( num2words(test[0], lang='fr_CH', to='currency', currency='FRF'), test[1] ) num2words-0.5.14/tests/test_fr_dz.py000066400000000000000000000043421473005321200174200ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words from . import test_fr TEST_CASES_TO_CURRENCY = ( (1, 'un dinard'), (2, 'deux dinards'), (8, 'huit dinards'), (12, 'douze dinards'), (21, 'vingt et un dinards'), (81.25, 'quatre-vingt-un dinards et vingt-cinq centimes'), (100, 'cent dinards'), ) class Num2WordsPLTest(TestCase): def test_currency(self): self.assertEqual( num2words(1234.12, lang='fr_DZ', to='currency'), "mille deux cent trente-quatre dinards et douze centimes" ) self.assertEqual( num2words(45689.89, lang='fr_DZ', to='currency'), "quarante-cinq mille six cent quatre-vingt-neuf dinards et " "quatre-vingt-neuf centimes" ) def test_number(self): for test in test_fr.TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='fr_DZ'), test[1]) def test_ordinal(self): for test in test_fr.TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='fr_DZ', ordinal=True), test[1] ) def test_ordinal_num(self): for test in test_fr.TEST_CASES_ORDINAL_NUM: self.assertEqual( num2words(test[0], lang='fr_DZ', to='ordinal_num'), test[1] ) num2words-0.5.14/tests/test_he.py000066400000000000000000000717741473005321200167250ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words from num2words.lang_HE import Num2Word_HE, int2word class Num2WordsHETest(TestCase): maxDiff = None def test_negative(self): self.assertEqual(num2words(-1, lang="he"), u'מינוס אחת') def test_0(self): self.assertEqual(num2words(0, lang="he"), u'אפס') def test_1_to_10(self): self.assertEqual(num2words(1, lang="he"), u'אחת') self.assertEqual(num2words(2, lang="he"), u'שתיים') self.assertEqual(num2words(7, lang="he"), u'שבע') self.assertEqual(num2words(10, lang="he"), u'עשר') self.assertEqual(num2words( 10, lang="he", gender='m', construct=True), u'עשרת') def test_11_to_19(self): self.assertEqual(num2words(11, lang="he"), u'אחת עשרה') self.assertEqual(num2words(11, lang="he", gender='m'), u'אחד עשר') self.assertEqual(num2words(13, lang="he"), u'שלוש עשרה') self.assertEqual(num2words( 13, lang="he", construct=True), u'שלוש עשרה') self.assertEqual(num2words(15, lang="he"), u'חמש עשרה') self.assertEqual(num2words(16, lang="he"), u'שש עשרה') self.assertEqual(num2words(16, lang="he", gender='m'), u'שישה עשר') self.assertEqual(num2words( 16, lang="he", gender='m', construct=True), u'שישה עשר') self.assertEqual(num2words(19, lang="he"), u'תשע עשרה') def test_20_to_99(self): self.assertEqual(num2words(20, lang="he"), u'עשרים') self.assertEqual(num2words(23, lang="he"), u'עשרים ושלוש') self.assertEqual(num2words(23, lang="he", gender='m'), u'עשרים ושלושה') self.assertEqual(num2words( 23, lang="he", construct=True), u'עשרים ושלוש') self.assertEqual(num2words( 23, lang="he", gender='m', construct=True), u'עשרים ושלושה') self.assertEqual(num2words(28, lang="he"), u'עשרים ושמונה') self.assertEqual(num2words(31, lang="he"), u'שלושים ואחת') self.assertEqual(num2words(40, lang="he"), u'ארבעים') self.assertEqual(num2words(66, lang="he"), u'שישים ושש') self.assertEqual(num2words(92, lang="he"), u'תשעים ושתיים') def test_100_to_999(self): self.assertEqual(num2words(100, lang="he"), u'מאה') self.assertEqual(num2words(100, lang="he", construct=True), u'מאת') self.assertEqual(num2words(111, lang="he"), u'מאה ואחת עשרה') self.assertEqual(num2words( 111, lang="he", construct=True), u'מאה ואחת עשרה') self.assertEqual(num2words(150, lang="he"), u'מאה וחמישים') self.assertEqual(num2words(196, lang="he"), u'מאה תשעים ושש') self.assertEqual(num2words( 196, lang="he", gender='m'), u'מאה תשעים ושישה') self.assertEqual(num2words( 196, lang="he", gender='m', construct=True), u'מאה תשעים ושישה') self.assertEqual(num2words(200, lang="he"), u'מאתיים') self.assertEqual(num2words(200, lang="he", construct=True), u'מאתיים') self.assertEqual(num2words(210, lang="he"), u'מאתיים ועשר') self.assertEqual(num2words(701, lang="he"), u'שבע מאות ואחת') def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang="he"), u'אלף') self.assertEqual(num2words(1000, lang="he", construct=True), u'אלף') self.assertEqual(num2words(1001, lang="he"), u'אלף ואחת') self.assertEqual(num2words(1002, lang="he"), u'אלף ושתיים') self.assertEqual(num2words(1002, lang="he", gender='m'), u'אלף ושניים') self.assertEqual(num2words( 1002, lang="he", gender='m', construct=True), u'אלף ושניים') self.assertEqual(num2words(1003, lang="he"), u'אלף ושלוש') self.assertEqual(num2words(1003, lang="he", gender='m'), u'אלף ושלושה') self.assertEqual(num2words( 1003, lang="he", gender='m', construct=True), u'אלף ושלושה') self.assertEqual(num2words(1010, lang="he"), u'אלף ועשר') self.assertEqual(num2words(1010, lang="he", gender='m'), u'אלף ועשרה') self.assertEqual(num2words( 1010, lang="he", gender='m', construct=True), u'אלף ועשרה') self.assertEqual(num2words(1500, lang="he"), u'אלף וחמש מאות') self.assertEqual(num2words(2000, lang="he"), u'אלפיים') self.assertEqual(num2words(2000, lang="he", construct=True), u'אלפיים') self.assertEqual(num2words(2002, lang="he"), u'אלפיים ושתיים') self.assertEqual(num2words( 2002, lang="he", construct=True), u'אלפיים ושתיים') self.assertEqual(num2words(3000, lang="he"), u'שלושת אלפים') self.assertEqual(num2words( 3000, lang="he", construct=True), u'שלושת אלפי') self.assertEqual(num2words(3001, lang="he"), u'שלושת אלפים ואחת') self.assertEqual(num2words( 3001, lang="he", construct=True), u'שלושת אלפים ואחת') self.assertEqual(num2words(3100, lang="he"), u'שלושת אלפים ומאה') self.assertEqual(num2words( 3100, lang="he", construct=True), u'שלושת אלפים ומאה') self.assertEqual(num2words( 6870, lang="he"), u'ששת אלפים שמונה מאות ושבעים') self.assertEqual(num2words( 7378, lang="he"), u'שבעת אלפים שלוש מאות שבעים ושמונה') self.assertEqual(num2words( 9999, lang="he"), u'תשעת אלפים תשע מאות תשעים ותשע') def test_10000_to_99999(self): self.assertEqual(num2words(10000, lang="he"), u'עשרת אלפים') self.assertEqual(num2words( 10000, lang="he", construct=True), u'עשרת אלפי') self.assertEqual(num2words(10001, lang="he"), u'עשרת אלפים ואחת') self.assertEqual(num2words( 10001, lang="he", construct=True), u'עשרת אלפים ואחת') self.assertEqual(num2words( 10999, lang="he"), u'עשרת אלפים תשע מאות תשעים ותשע') self.assertEqual(num2words(11000, lang="he"), u'אחד עשר אלף') self.assertEqual(num2words(15000, lang="he"), u'חמישה עשר אלף') self.assertEqual(num2words( 15000, lang="he", gender='m'), u'חמישה עשר אלף') self.assertEqual(num2words(20000, lang="he"), u'עשרים אלף') self.assertEqual(num2words( 20000, lang="he", construct=True), u'עשרים אלף') self.assertEqual(num2words(21000, lang="he"), u'עשרים ואחד אלף') self.assertEqual(num2words(25000, lang="he"), u'עשרים וחמישה אלף') self.assertEqual(num2words( 25000, lang="he", construct=True), u'עשרים וחמישה אלף') self.assertEqual(num2words( 68700, lang="he"), u'שישים ושמונה אלף ושבע מאות') self.assertEqual(num2words( 73781, lang="he"), u'שבעים ושלושה אלף שבע מאות שמונים ואחת') self.assertEqual(num2words( 99999, lang="he"), u'תשעים ותשעה אלף תשע מאות תשעים ותשע') def test_100000_to_999999(self): self.assertEqual(num2words(100000, lang="he"), u'מאה אלף') self.assertEqual(num2words( 100000, lang="he", construct=True), u'מאה אלף') self.assertEqual(num2words(100001, lang="he"), u'מאה אלף ואחת') self.assertEqual(num2words( 199999, lang="he"), u'מאה תשעים ותשעה אלף תשע מאות תשעים ותשע') self.assertEqual(num2words(110000, lang="he"), u'מאה ועשרה אלף') self.assertEqual(num2words(150000, lang="he"), u'מאה וחמישים אלף') self.assertEqual(num2words(200000, lang="he"), u'מאתיים אלף') self.assertEqual(num2words(210000, lang="he"), u'מאתיים ועשרה אלף') self.assertEqual(num2words( 687000, lang="he"), u'שש מאות שמונים ושבעה אלף') self.assertEqual(num2words( 687000, lang="he", construct=True), u'שש מאות שמונים ושבעה אלף') self.assertEqual(num2words(737812, lang="he"), u'שבע מאות שלושים ושבעה אלף שמונה מאות ושתים עשרה') self.assertEqual(num2words(999999, lang="he"), u'תשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשע') def test_1000000_to_999999999999999(self): self.assertEqual(num2words(1000000, lang="he"), u'מיליון') self.assertEqual(num2words( 1000000, lang="he", construct=True), u'מיליון') self.assertEqual(num2words(1000002, lang="he"), u'מיליון ושתיים') self.assertEqual(num2words( 1000002, lang="he", construct=True), u'מיליון ושתיים') self.assertEqual(num2words(2000000, lang="he"), u'שני מיליון') self.assertEqual(num2words( 2000000, lang="he", construct=True), u'שני מיליוני') self.assertEqual(num2words(3000000, lang="he"), u'שלושה מיליון') self.assertEqual(num2words( 3000000, lang="he", construct=True), u'שלושת מיליוני') self.assertEqual(num2words(3000002, lang="he"), u'שלושה מיליון ושתיים') self.assertEqual(num2words( 3000002, lang="he", construct=True), u'שלושה מיליון ושתיים') self.assertEqual(num2words(10000000, lang="he"), u'עשרה מיליון') self.assertEqual(num2words( 10000000, lang="he", construct=True), 'עשרת מיליוני') self.assertEqual(num2words(11000000, lang="he"), u'אחד עשר מיליון') self.assertEqual(num2words( 11000000, lang="he", construct=True), 'אחד עשר מיליוני') self.assertEqual(num2words(1000000000, lang="he"), u'מיליארד') self.assertEqual(num2words( 1000000000, lang="he", construct=True), u'מיליארד') self.assertEqual(num2words(1000000002, lang="he"), u'מיליארד ושתיים') self.assertEqual(num2words( 1000000002, lang="he", construct=True), u'מיליארד ושתיים') self.assertEqual(num2words(2000000000, lang="he"), u'שני מיליארד') self.assertEqual(num2words( 2000000000, lang="he", construct=True), u'שני מיליארדי') self.assertEqual(num2words(3000000000, lang="he"), u'שלושה מיליארד') self.assertEqual(num2words( 3000000000, lang="he", construct=True), u'שלושת מיליארדי') self.assertEqual(num2words( 3000000002, lang="he"), u'שלושה מיליארד ושתיים') self.assertEqual(num2words( 3000000002, lang="he", construct=True), u'שלושה מיליארד ושתיים') self.assertEqual(num2words(10000000000, lang="he"), u'עשרה מיליארד') self.assertEqual(num2words( 10000000000, lang="he", construct=True), 'עשרת מיליארדי') self.assertEqual(num2words( 10000000002, lang="he"), u'עשרה מיליארד ושתיים') self.assertEqual(num2words( 10000000002, lang="he", construct=True), 'עשרה מיליארד ושתיים') self.assertEqual(num2words(11000000000, lang="he"), u'אחד עשר מיליארד') self.assertEqual(num2words( 11000000000, lang="he", construct=True), 'אחד עשר מיליארדי') self.assertEqual(num2words(1000000000000, lang="he"), u'טריליון') self.assertEqual(num2words( 1000000000000, lang="he", construct=True), u'טריליון') self.assertEqual(num2words( 1000000000002, lang="he"), u'טריליון ושתיים') self.assertEqual(num2words( 1000000000002, lang="he", construct=True), u'טריליון ושתיים') self.assertEqual(num2words(2000000000000, lang="he"), u'שני טריליון') self.assertEqual(num2words( 2000000000000, lang="he", construct=True), u'שני טריליוני') self.assertEqual(num2words(3000000000000, lang="he"), u'שלושה טריליון') self.assertEqual(num2words( 3000000000000, lang="he", construct=True), u'שלושת טריליוני') self.assertEqual(num2words( 3000000000002, lang="he"), u'שלושה טריליון ושתיים') self.assertEqual(num2words( 3000000000002, lang="he", construct=True), u'שלושה טריליון ושתיים') self.assertEqual(num2words(10000000000000, lang="he"), u'עשרה טריליון') self.assertEqual(num2words( 10000000000000, lang="he", construct=True), 'עשרת טריליוני') self.assertEqual(num2words( 10000000000002, lang="he"), u'עשרה טריליון ושתיים') self.assertEqual(num2words( 10000000000002, lang="he", construct=True), 'עשרה טריליון ושתיים') self.assertEqual(num2words( 11000000000000, lang="he"), u'אחד עשר טריליון') self.assertEqual(num2words( 11000000000000, lang="he", construct=True), 'אחד עשר טריליוני') self.assertEqual(num2words(999999999999999, lang="he"), u'תשע מאות תשעים ותשעה טריליון ' u'תשע מאות תשעים ותשעה מיליארד ' u'תשע מאות תשעים ותשעה מיליון ' u'תשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשע') self.assertEqual(num2words(999999999999999, lang="he", gender='m'), u'תשע מאות תשעים ותשעה טריליון ' u'תשע מאות תשעים ותשעה מיליארד ' u'תשע מאות תשעים ותשעה מיליון ' u'תשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשעה') self.assertEqual(num2words(999999999999999, lang="he", construct=True), u'תשע מאות תשעים ותשעה טריליון ' u'תשע מאות תשעים ותשעה מיליארד ' u'תשע מאות תשעים ותשעה מיליון ' u'תשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשע') self.assertEqual(num2words( 999999999999999, lang="he", gender='m', construct=True), u'תשע מאות תשעים ותשעה טריליון ' u'תשע מאות תשעים ותשעה מיליארד ' u'תשע מאות תשעים ותשעה מיליון ' u'תשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשעה') def test_pluralize(self): n = Num2Word_HE() cr1, cr2 = n.CURRENCY_FORMS['ILS'] self.assertEqual(n.pluralize(1, cr1), u'שקל') self.assertEqual(n.pluralize(2, cr1), u'שקלים') self.assertEqual(n.pluralize(1, cr2), u'אגורה') self.assertEqual(n.pluralize(2, cr2), u'אגורות') cr1, cr2 = n.CURRENCY_FORMS['USD'] self.assertEqual(n.pluralize(1, cr1), u'דולר') self.assertEqual(n.pluralize(2, cr1), u'דולרים') self.assertEqual(n.pluralize(1, cr2), u'סנט') self.assertEqual(n.pluralize(2, cr2), u'סנטים') def test_to_currency(self): n = Num2Word_HE() self.assertEqual(n.to_currency( 20.0, currency='ILS'), u'עשרים שקלים ואפס אגורות') self.assertEqual(n.to_currency( 100.0, currency='ILS'), u'מאה שקלים ואפס אגורות') self.assertEqual(n.to_currency( 100.50, currency='ILS'), u'מאה שקלים וחמישים אגורות') self.assertEqual(n.to_currency( 101.51, currency='ILS'), u'מאה ואחד שקלים וחמישים ואחת אגורות') self.assertEqual(n.to_currency( -101.51, currency='ILS'), u'מינוס מאה ואחד שקלים וחמישים ואחת אגורות') self.assertEqual(n.to_currency( -101.51, currency='ILS', prefer_singular=True), u'מינוס מאה ואחד שקל וחמישים ואחת אגורות') self.assertEqual(n.to_currency( -101.51, currency='ILS', prefer_singular_cents=True), u'מינוס מאה ואחד שקלים וחמישים ואחת אגורה') self.assertEqual(n.to_currency( -101.51, currency='ILS', prefer_singular=True, prefer_singular_cents=True), u'מינוס מאה ואחד שקל וחמישים ואחת אגורה') self.assertEqual(n.to_currency( 5.05, currency='ILS', prefer_singular=True, prefer_singular_cents=True), u'חמישה שקלים וחמש אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', prefer_singular=True, prefer_singular_cents=True), u'מינוס חמישה שקלים וחמש אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False), u'מינוס חמישה שקלים ו-05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator='ו'), u'מינוס חמישה שקלים ו-05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator='ו-'), u'מינוס חמישה שקלים ו-05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator=''), u'מינוס חמישה שקלים 05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator='ועוד '), u'מינוס חמישה שקלים ועוד 05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator=' ו'), u'מינוס חמישה שקלים ו-05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator=' ו-'), u'מינוס חמישה שקלים ו-05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator=' '), u'מינוס חמישה שקלים 05 אגורות') self.assertEqual(n.to_currency( -5.05, currency='ILS', cents=False, separator=' ועוד '), u'מינוס חמישה שקלים ועוד 05 אגורות') self.assertEqual(n.to_currency( 1.01, currency='ILS'), u'שקל אחד ואגורה אחת') self.assertEqual(n.to_currency( -1.01, currency='ILS'), u'מינוס שקל אחד ואגורה אחת') self.assertEqual(n.to_currency( 2.02, currency='ILS'), u'שני שקלים ושתי אגורות') self.assertEqual(n.to_currency( 1002.02, currency='ILS'), u'אלף ושניים שקלים ושתי אגורות') self.assertEqual(n.to_currency( 1000002.02, currency='ILS'), u'מיליון ושניים שקלים ושתי אגורות') self.assertEqual(n.to_currency( 5.05, currency='USD'), u'חמישה דולרים וחמישה סנטים') self.assertEqual(n.to_currency( 5.05, currency='USD', prefer_singular=True), u'חמישה דולר וחמישה סנטים') self.assertEqual(n.to_currency( 5.05, currency='USD', prefer_singular_cents=True), u'חמישה דולרים וחמישה סנט') self.assertEqual(n.to_currency( 5.05, currency='USD', prefer_singular=True, prefer_singular_cents=True), u'חמישה דולר וחמישה סנט') n.CURRENCY_FORMS['pruta'] = (('פרוטה', 'פרוטות'), ('מאית', 'מאיות')) self.assertEqual(n.to_currency( 5.05, currency='pruta'), u'חמש פרוטות וחמש מאיות') def test_to_currency_errors(self): n = Num2Word_HE() with self.assertRaises(NotImplementedError): n.to_currency(1, '') def test_to_cardinal(self): n = Num2Word_HE() self.assertEqual(n.to_cardinal(1500), u'אלף וחמש מאות') self.assertEqual(n.to_cardinal(1501), u'אלף חמש מאות ואחת') self.assertEqual(num2words(1, lang='he'), u'אחת') self.assertEqual(num2words(1, lang='he', gender='m'), u'אחד') def test_to_ordinal(self): n = Num2Word_HE() self.assertEqual(n.to_ordinal(1001), u'האלף ואחד') self.assertEqual(n.to_ordinal(1500), u'האלף וחמש מאות') self.assertEqual(n.to_ordinal(1501), u'האלף חמש מאות ואחד') self.assertEqual(n.to_ordinal( 1501, definite=True), u'האלף חמש מאות ואחד') self.assertEqual(n.to_ordinal(1), u'ראשון') self.assertEqual(n.to_ordinal(1, definite=True), u'הראשון') self.assertEqual(n.to_ordinal(1, gender='f'), u'ראשונה') self.assertEqual(n.to_ordinal( 1, gender='f', definite=True), u'הראשונה') self.assertEqual(n.to_ordinal(10), u'עשירי') self.assertEqual(n.to_ordinal(10, definite=True), u'העשירי') self.assertEqual(n.to_ordinal(10, gender='f'), u'עשירית') self.assertEqual(n.to_ordinal( 10, gender='f', definite=True), u'העשירית') self.assertEqual(n.to_ordinal(17), u'השבעה עשר') self.assertEqual(n.to_ordinal(17, definite=True), u'השבעה עשר') self.assertEqual(n.to_ordinal(17, gender='f'), u'השבע עשרה') self.assertEqual(n.to_ordinal( 17, gender='f', definite=True), u'השבע עשרה') self.assertEqual(n.to_ordinal(0), u'האפס') self.assertEqual(n.to_ordinal(0, definite=True), u'האפס') self.assertEqual(n.to_ordinal(0, gender='f'), u'האפס') self.assertEqual(n.to_ordinal(0, gender='f', definite=True), u'האפס') self.assertEqual(n.to_ordinal( 999999), u'התשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשעה') self.assertEqual(n.to_ordinal( 999999, gender='f'), u'התשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשע') self.assertEqual(num2words(1, ordinal=True, lang='he'), u'ראשון') self.assertEqual(num2words( 1, ordinal=True, lang='he', gender='f'), u'ראשונה') self.assertEqual(num2words( 1, ordinal=True, lang='he', definite=True), u'הראשון') self.assertEqual(num2words( 1, ordinal=True, lang='he', gender='f', definite=True), u'הראשונה') def test_to_ordinal_plural(self): n = Num2Word_HE() self.assertEqual(n.to_ordinal(1001, plural=True), u'האלף ואחד') self.assertEqual(n.to_ordinal(1500, plural=True), u'האלף וחמש מאות') self.assertEqual(n.to_ordinal( 1501, plural=True), u'האלף חמש מאות ואחד') self.assertEqual(n.to_ordinal( 1501, definite=True, plural=True), u'האלף חמש מאות ואחד') self.assertEqual(n.to_ordinal(1, plural=True), u'ראשונים') self.assertEqual(n.to_ordinal( 1, definite=True, plural=True), u'הראשונים') self.assertEqual(n.to_ordinal(1, gender='f', plural=True), u'ראשונות') self.assertEqual(n.to_ordinal( 1, gender='f', definite=True, plural=True), u'הראשונות') self.assertEqual(n.to_ordinal(10, plural=True), u'עשיריים') self.assertEqual(n.to_ordinal( 10, definite=True, plural=True), u'העשיריים') self.assertEqual(n.to_ordinal( 10, gender='f', plural=True), u'עשיריות') self.assertEqual(n.to_ordinal( 10, gender='f', definite=True, plural=True), u'העשיריות') self.assertEqual(n.to_ordinal(17, plural=True), u'השבעה עשר') self.assertEqual(n.to_ordinal( 17, definite=True, plural=True), u'השבעה עשר') self.assertEqual(n.to_ordinal( 17, gender='f', plural=True), u'השבע עשרה') self.assertEqual(n.to_ordinal( 17, gender='f', definite=True, plural=True), u'השבע עשרה') self.assertEqual(n.to_ordinal(0, plural=True), u'האפס') self.assertEqual(n.to_ordinal(0, definite=True, plural=True), u'האפס') self.assertEqual(n.to_ordinal(0, gender='f', plural=True), u'האפס') self.assertEqual(n.to_ordinal( 0, gender='f', definite=True, plural=True), u'האפס') self.assertEqual(n.to_ordinal(999999, plural=True), u'התשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשעה') self.assertEqual(n.to_ordinal(999999, gender='f', plural=True), u'התשע מאות תשעים ותשעה אלף תשע מאות תשעים ותשע') self.assertEqual(num2words( 1, ordinal=True, lang='he', plural=True), u'ראשונים') self.assertEqual(num2words( 1, ordinal=True, lang='he', gender='f', plural=True), u'ראשונות') self.assertEqual(num2words(1, ordinal=True, lang='he', definite=True, plural=True), u'הראשונים') self.assertEqual(num2words(1, ordinal=True, lang='he', gender='f', definite=True, plural=True), u'הראשונות') def test_cardinal_for_float_number(self): self.assertEqual(num2words(12.5, lang='he'), u'שתים עשרה נקודה חמש') self.assertEqual(num2words( 12.51, lang='he'), u'שתים עשרה נקודה חמש אחת') self.assertEqual(num2words( 12.53, lang='he'), u'שתים עשרה נקודה חמש שלוש') self.assertEqual(num2words( 12.59, lang='he'), u'שתים עשרה נקודה חמש תשע') self.assertEqual(num2words( 12.5, lang='he', gender='m'), u'שנים עשר נקודה חמש') self.assertEqual(num2words( 12.51, lang='he', gender='m'), u'שנים עשר נקודה חמש אחת') self.assertEqual(num2words( 12.53, lang='he', gender='m'), u'שנים עשר נקודה חמש שלוש') self.assertEqual(num2words( 12.59, lang='he', gender='m'), u'שנים עשר נקודה חמש תשע') self.assertEqual(num2words(12.594132, lang='he', gender='m'), u'שנים עשר נקודה חמש תשע ארבע אחת שלוש שתיים') def test_cardinal_float_precision(self): n = Num2Word_HE() self.assertEqual(n.to_cardinal_float("1.23"), 'אחת נקודה שתיים שלוש') n.precision = 1 self.assertEqual(n.to_cardinal_float("1.2"), 'אחת נקודה שתיים') def test_error_to_cardinal_float(self): n = Num2Word_HE() with self.assertRaises(TypeError): n.to_cardinal_float("a") def test_overflow(self): n = Num2Word_HE() num2words(n.MAXVAL - 1, lang="he") num2words(n.MAXVAL - 1, ordinal=True, lang="he") with self.assertRaises(OverflowError): num2words(n.MAXVAL, lang="he") with self.assertRaises(OverflowError): num2words(n.MAXVAL, lang="he", ordinal=True) with self.assertRaises(OverflowError): int2word(n.MAXVAL) num2words-0.5.14/tests/test_hu.py000066400000000000000000000200241473005321200167230ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsHUTest(TestCase): def test_and_join_199(self): # ref https://github.com/savoirfairelinux/num2words/issues/8 self.assertEqual(num2words(199), "one hundred and ninety-nine") def test_cardinal(self): self.assertEqual( num2words(-1, lang='hu'), 'mínusz egy' ) self.assertEqual( num2words(0, lang='hu'), 'nulla' ) self.assertEqual( num2words(1, lang='hu'), 'egy' ) self.assertEqual( num2words(13, lang='hu'), 'tizenhárom' ) self.assertEqual( num2words(22, lang='hu'), 'huszonkettő' ) self.assertEqual( num2words(75, lang='hu'), 'hetvenöt' ) self.assertEqual( num2words(124, lang='hu'), 'százhuszonnégy' ) self.assertEqual( num2words(651, lang='hu'), 'hatszázötvenegy' ) self.assertEqual( num2words(2232, lang='hu'), 'kétezer-kétszázharminckettő' ) self.assertEqual( num2words(16501, lang='hu'), 'tizenhatezer-ötszázegy' ) self.assertEqual( num2words(1900000000000, lang='hu'), 'egybillió-kilencszázmilliárd' ) self.assertEqual( num2words(24656451324564987566, lang='hu'), 'huszonnégytrillió-hatszázötvenhatbilliárd-négyszázötvenegybillió' '-háromszázhuszonnégymilliárd-ötszázhatvannégymillió-' 'kilencszáznyolcvanhétezer-ötszázhatvanhat' ) def test_ordinal(self): self.assertEqual( num2words(0, lang='hu', to='ordinal'), 'nulladik' ) self.assertEqual( num2words(1, lang='hu', to='ordinal'), 'első' ) self.assertEqual( num2words(2, lang='hu', to='ordinal'), 'második' ) self.assertEqual( num2words(-3, lang='hu', to='ordinal'), 'mínusz harmadik' ) self.assertEqual( num2words(13, lang='hu', to='ordinal'), 'tizenharmadik' ) self.assertEqual( num2words(22, lang='hu', to='ordinal'), 'huszonkettedik' ) self.assertEqual( num2words(75, lang='hu', to='ordinal'), 'hetvenötödik' ) self.assertEqual( num2words(124, lang='hu', to='ordinal'), 'százhuszonnegyedik' ) self.assertEqual( num2words(1532, lang='hu', to='ordinal'), 'ezerötszázharminckettedik' ) self.assertEqual( num2words(16501, lang='hu', to='ordinal'), 'tizenhatezer-ötszázegyedik' ) self.assertEqual( num2words(458755640120000, lang='hu', to='ordinal'), 'négyszázötvennyolcbillió-hétszázötvenötmilliárd-' 'hatszáznegyvenmillió-százhúszezredik' ) def test_ordinal_num(self): self.assertEqual(num2words(10, lang='hu', to='ordinal_num'), '10.') self.assertEqual(num2words(21, lang='hu', to='ordinal_num'), '21.') self.assertEqual(num2words(102, lang='hu', to='ordinal_num'), '102.') self.assertEqual(num2words(73, lang='hu', to='ordinal_num'), '73.') def test_cardinal_for_float_number(self): # issue 24 self.assertEqual(num2words(12, lang='hu'), "tizenkettő") self.assertEqual(num2words(12.0, lang='hu'), "tizenkettő") self.assertEqual(num2words(12.5, lang='hu'), "tizenkettő egész öt tized") self.assertEqual(num2words(-12.5, lang='hu'), "mínusz tizenkettő egész öt tized") self.assertEqual(num2words(12.51, lang='hu'), "tizenkettő egész ötvenegy század") self.assertEqual(num2words(12.53, lang='hu'), "tizenkettő egész ötvenhárom század") self.assertEqual(num2words(12.590, lang='hu'), "tizenkettő egész ötvenkilenc század") self.assertEqual(num2words(12.005, lang='hu'), "tizenkettő egész öt ezred") def test_overflow(self): with self.assertRaises(OverflowError): num2words("1000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000") def test_to_currency(self): self.assertEqual( num2words('38.4', lang='hu', to='currency', separator=' és', cents=False, currency='HUF'), "harmincnyolc forint és 40 fillér" ) self.assertEqual( num2words('0', lang='hu', to='currency', separator=' és', cents=False, currency='HUF'), "nulla forint és 00 fillér" ) self.assertEqual( num2words('1.01', lang='hu', to='currency', separator=' és', cents=True, currency='HUF'), "egy forint és egy fillér" ) self.assertEqual( num2words('4778.00', lang='hu', to='currency', separator=' és', cents=True, currency='HUF', adjective=True), 'négyezer-hétszázhetvennyolc Hungarian forint' ' és nulla fillér') self.assertEqual( num2words('4778.00', lang='hu', to='currency', separator=' és', cents=True, currency='HUF'), 'négyezer-hétszázhetvennyolc forint és nulla fillér') def test_to_year(self): # issue 141 # "e2 e2" self.assertEqual(num2words(1990, lang='hu', to='year'), 'ezerkilencszázkilencven') self.assertEqual(num2words(5555, lang='hu', to='year'), 'ötezer-ötszázötvenöt') self.assertEqual(num2words(2020, lang='hu', to='year'), 'kétezer-húsz') self.assertEqual(num2words(905, lang='hu', to='year'), 'kilencszázöt') self.assertEqual(num2words(0, lang='hu', to='year'), 'nulla') # suffixes self.assertEqual(num2words(-44, lang='hu', to='year'), 'i. e. negyvennégy') self.assertEqual(num2words(-44, lang='hu', to='year', suffix='Kr. e.'), 'Kr. e. negyvennégy') self.assertEqual(num2words(1, lang='hu', to='year', suffix='Kr. u.'), 'Kr. u. egy') self.assertEqual(num2words(-66000000, lang='hu', to='year'), 'i. e. hatvanhatmillió') num2words-0.5.14/tests/test_id.py000066400000000000000000000050121473005321200167030ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsIDTest(TestCase): def test_cardinal_for_natural_number(self): self.assertEqual(num2words(10, lang='id'), "sepuluh") self.assertEqual(num2words(11, lang='id'), "sebelas") self.assertEqual(num2words(108, lang='id'), "seratus delapan") self.assertEqual(num2words(1075, lang='id'), "seribu tujuh puluh lima") self.assertEqual( num2words(1087231, lang='id'), "satu juta delapan puluh tujuh ribu dua ratus tiga puluh satu" ) self.assertEqual( num2words(1000000408, lang='id'), "satu miliar empat ratus delapan" ) def test_cardinal_for_decimal_number(self): self.assertEqual( num2words(12.234, lang='id'), "dua belas koma dua tiga empat" ) self.assertEqual( num2words(9.076, lang='id'), "sembilan koma nol tujuh enam" ) def test_cardinal_for_negative_number(self): self.assertEqual( num2words(-923, lang='id'), "min sembilan ratus dua puluh tiga" ) self.assertEqual( num2words(-0.234, lang='id'), "min nol koma dua tiga empat" ) def test_ordinal_for_natural_number(self): self.assertEqual(num2words(1, ordinal=True, lang='id'), "pertama") self.assertEqual(num2words(10, ordinal=True, lang='id'), "kesepuluh") def test_ordinal_for_negative_number(self): self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='id') def test_ordinal_for_floating_number(self): self.assertRaises(TypeError, num2words, 3.243, ordinal=True, lang='id') num2words-0.5.14/tests/test_is.py000066400000000000000000000071201473005321200167240ustar00rootroot00000000000000# 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 unittest import TestCase from num2words import num2words class Num2WordsISTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(0, to="cardinal", lang="is"), "núll") self.assertEqual(num2words(1, to="cardinal", lang="is"), "einn") self.assertEqual(num2words(45, to="cardinal", lang="is"), "fjörutíu og fimm") self.assertEqual(num2words(145, to="cardinal", lang="is"), "eitt hundrað fjörutíu og fimm") self.assertEqual(num2words(-1245, to="cardinal", lang="is"), "mínus eitt þúsund tvö hundruð fjörutíu og fimm") self.assertEqual(num2words(2234045, to="cardinal", lang="is"), "tvær milljónir tvö hundruð þrjátíu og fjögur þúsund " "fjörutíu og fimm") self.assertEqual(num2words(4002234045, to="cardinal", lang="is"), "fjórir milljarðar tvær milljónir tvö hundruð " "þrjátíu og fjögur þúsund fjörutíu og fimm") def test_cardinal_for_float_number(self): self.assertEqual(num2words(12.5, to="cardinal", lang="is"), "tólf komma fimm") self.assertEqual(num2words(12.51, to="cardinal", lang="is"), "tólf komma fimm einn") self.assertEqual(num2words(-12.53, to="cardinal", lang="is"), "mínus tólf komma fimm þrír") self.assertEqual(num2words(12.59, to="cardinal", lang="is"), "tólf komma fimm níu") def test_overflow(self): with self.assertRaises(OverflowError): num2words("1000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000", lang="is") def test_not_implemented(self): # Ordinals with self.assertRaises(NotImplementedError): num2words(1, to="ordinal", lang="is") # Ordinal num with self.assertRaises(NotImplementedError): num2words(1, to="ordinal_num", lang="is") # Year with self.assertRaises(NotImplementedError): num2words(1, to="year", lang="is") # Currency with self.assertRaises(NotImplementedError): num2words(1, to="currency", lang="is") num2words-0.5.14/tests/test_it.py000066400000000000000000000307301473005321200167300ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_TO_CURRENCY_EUR = ( (1.00, 'un euro e zero centesimi'), (2.01, 'due euro e un centesimo'), (8.10, 'otto euro e dieci centesimi'), (12.26, 'dodici euro e ventisei centesimi'), (21.29, 'ventun euro e ventinove centesimi'), (81.25, 'ottantun euro e venticinque centesimi'), (100.00, 'cento euro e zero centesimi'), ) TEST_CASES_TO_CURRENCY_USD = ( (1.00, 'un dollaro e zero centesimi'), (2.01, 'due dollari e un centesimo'), (8.10, 'otto dollari e dieci centesimi'), (12.26, 'dodici dollari e ventisei centesimi'), (21.29, 'ventun dollari e ventinove centesimi'), (81.25, 'ottantun dollari e venticinque centesimi'), (100.00, 'cento dollari e zero centesimi'), ) TEST_CASES_TO_CURRENCY_GBP = ( (1.00, 'una sterlina e zero penny'), (2.01, 'due sterline e un penny'), (8.10, 'otto sterline e dieci penny'), (12.26, 'dodici sterline e ventisei penny'), (21.29, 'ventun sterline e ventinove penny'), (81.25, 'ottantun sterline e venticinque penny'), (100.00, 'cento sterline e zero penny'), ) class Num2WordsITTest(TestCase): maxDiff = None def test_negative(self): number = 648972145 pos_crd = num2words(+number, lang="it") neg_crd = num2words(-number, lang="it") pos_ord = num2words(+number, lang="it", ordinal=True) neg_ord = num2words(-number, lang="it", ordinal=True) self.assertEqual("meno " + pos_crd, neg_crd) self.assertEqual("meno " + pos_ord, neg_ord) def test_float_to_cardinal(self): self.assertEqual( num2words(3.1415, lang="it"), "tre virgola uno quattro uno cinque" ) self.assertEqual( num2words(-5.15, lang="it"), "meno cinque virgola uno cinque" ) self.assertEqual( num2words(-0.15, lang="it"), "meno zero virgola uno cinque" ) def test_float_to_ordinal(self): self.assertEqual( num2words(3.1415, lang="it", ordinal=True), "terzo virgola uno quattro uno cinque" ) self.assertEqual( num2words(-5.15, lang="it", ordinal=True), "meno quinto virgola uno cinque" ) self.assertEqual( num2words(-0.15, lang="it", ordinal=True), "meno zero virgola uno cinque" ) def test_0(self): self.assertEqual(num2words(0, lang="it"), "zero") self.assertEqual(num2words(0, lang="it", ordinal=True), "zero") def test_1_to_10(self): self.assertEqual(num2words(1, lang="it"), "uno") self.assertEqual(num2words(2, lang="it"), "due") self.assertEqual(num2words(7, lang="it"), "sette") self.assertEqual(num2words(10, lang="it"), "dieci") def test_11_to_19(self): self.assertEqual(num2words(11, lang="it"), "undici") self.assertEqual(num2words(13, lang="it"), "tredici") self.assertEqual(num2words(15, lang="it"), "quindici") self.assertEqual(num2words(16, lang="it"), "sedici") self.assertEqual(num2words(19, lang="it"), "diciannove") def test_20_to_99(self): self.assertEqual(num2words(20, lang="it"), "venti") self.assertEqual(num2words(21, lang="it"), "ventuno") self.assertEqual(num2words(23, lang="it"), "ventitré") self.assertEqual(num2words(28, lang="it"), "ventotto") self.assertEqual(num2words(31, lang="it"), "trentuno") self.assertEqual(num2words(40, lang="it"), "quaranta") self.assertEqual(num2words(66, lang="it"), "sessantasei") self.assertEqual(num2words(92, lang="it"), "novantadue") def test_100_to_999(self): self.assertEqual(num2words(100, lang="it"), "cento") self.assertEqual(num2words(111, lang="it"), "centoundici") self.assertEqual(num2words(150, lang="it"), "centocinquanta") self.assertEqual(num2words(196, lang="it"), "centonovantasei") self.assertEqual(num2words(200, lang="it"), "duecento") self.assertEqual(num2words(210, lang="it"), "duecentodieci") self.assertEqual(num2words(701, lang="it"), "settecentouno") def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang="it"), "mille") self.assertEqual(num2words(1001, lang="it"), "milleuno") self.assertEqual(num2words(1500, lang="it"), "millecinquecento") self.assertEqual( num2words(7378, lang="it"), "settemilatrecentosettantotto" ) self.assertEqual(num2words(2000, lang="it"), "duemila") self.assertEqual(num2words(2100, lang="it"), "duemilacento") self.assertEqual( num2words(6870, lang="it"), "seimilaottocentosettanta" ) self.assertEqual(num2words(10000, lang="it"), "diecimila") self.assertEqual( num2words(98765, lang="it"), "novantottomilasettecentosessantacinque" ) self.assertEqual(num2words(100000, lang="it"), "centomila") self.assertEqual( num2words(523456, lang="it"), "cinquecentoventitremilaquattrocentocinquantasei" ) def test_big(self): self.assertEqual(num2words(1000000, lang="it"), "un milione") self.assertEqual(num2words(1000007, lang="it"), "un milione e sette") self.assertEqual( num2words(1200000, lang="it"), "un milione e duecentomila" ) self.assertEqual(num2words(3000000, lang="it"), "tre milioni") self.assertEqual(num2words(3000005, lang="it"), "tre milioni e cinque") self.assertEqual( num2words(3800000, lang="it"), "tre milioni e ottocentomila" ) self.assertEqual(num2words(1000000000, lang="it"), "un miliardo") self.assertEqual( num2words(1000000017, lang="it"), "un miliardo e diciassette" ) self.assertEqual(num2words(2000000000, lang="it"), "due miliardi") self.assertEqual( num2words(2000001000, lang="it"), "due miliardi e mille" ) self.assertEqual( num2words(1234567890, lang="it"), "un miliardo, duecentotrentaquattro milioni e " "cinquecentosessantasettemilaottocentonovanta" ) self.assertEqual(num2words(1000000000000, lang="it"), "un bilione") self.assertEqual( num2words(123456789012345678901234567890, lang="it"), "centoventitré quadriliardi, quattrocentocinquantasei " "quadrilioni, settecentottantanove triliardi, dodici trilioni, " "trecentoquarantacinque biliardi, seicentosettantotto bilioni, " "novecentouno miliardi, duecentotrentaquattro milioni e " "cinquecentosessantasettemilaottocentonovanta" ) def test_nth_1_to_99(self): self.assertEqual(num2words(1, lang="it", ordinal=True), "primo") self.assertEqual(num2words(8, lang="it", ordinal=True), "ottavo") self.assertEqual( num2words(21, lang="it", ordinal=True), "ventunesimo" ) self.assertEqual( num2words(23, lang="it", ordinal=True), "ventitreesimo" ) self.assertEqual( num2words(47, lang="it", ordinal=True), "quarantasettesimo" ) self.assertEqual( num2words(99, lang="it", ordinal=True), "novantanovesimo" ) def test_nth_100_to_999(self): self.assertEqual(num2words(100, lang="it", ordinal=True), "centesimo") self.assertEqual( num2words(112, lang="it", ordinal=True), "centododicesimo" ) self.assertEqual( num2words(120, lang="it", ordinal=True), "centoventesimo" ) self.assertEqual( num2words(121, lang="it", ordinal=True), "centoventunesimo" ) self.assertEqual( num2words(316, lang="it", ordinal=True), "trecentosedicesimo" ) self.assertEqual( num2words(700, lang="it", ordinal=True), "settecentesimo" ) self.assertEqual( num2words(803, lang="it", ordinal=True), "ottocentotreesimo" ) self.assertEqual( num2words(923, lang="it", ordinal=True), "novecentoventitreesimo" ) def test_nth_1000_to_999999(self): self.assertEqual(num2words(1000, lang="it", ordinal=True), "millesimo") self.assertEqual( num2words(1001, lang="it", ordinal=True), "milleunesimo" ) self.assertEqual( num2words(1003, lang="it", ordinal=True), "milletreesimo" ) self.assertEqual( num2words(1200, lang="it", ordinal=True), "milleduecentesimo" ) self.assertEqual( num2words(8640, lang="it", ordinal=True), "ottomilaseicentoquarantesimo" ) self.assertEqual( num2words(14000, lang="it", ordinal=True), "quattordicimillesimo" ) self.assertEqual( num2words(123456, lang="it", ordinal=True), "centoventitremilaquattrocentocinquantaseiesimo" ) self.assertEqual( num2words(987654, lang="it", ordinal=True), "novecentottantasettemilaseicentocinquantaquattresimo" ) def test_nth_big(self): self.assertEqual( num2words(1000000001, lang="it", ordinal=True), "un miliardo e unesimo" ) self.assertEqual( num2words(123456789012345678901234567890, lang="it", ordinal=True), "centoventitré quadriliardi, quattrocentocinquantasei " "quadrilioni, settecentottantanove triliardi, dodici trilioni, " "trecentoquarantacinque biliardi, seicentosettantotto bilioni, " "novecentouno miliardi, duecentotrentaquattro milioni e " "cinquecentosessantasettemilaottocentonovantesimo" ) def test_with_floats(self): self.assertAlmostEqual( num2words(1.0, lang="it"), "uno virgola zero" ) self.assertAlmostEqual( num2words(1.1, lang="it"), "uno virgola uno" ) def test_with_strings(self): for i in range(2002): # Just make sure it doesn't raise an exception num2words(str(i), lang='it', to='cardinal') num2words(str(i), lang='it', to='ordinal') self.assertEqual(num2words('1', lang="it", to='ordinal'), "primo") self.assertEqual( num2words('100', lang="it", to='ordinal'), "centesimo" ) self.assertEqual( num2words('1000', lang="it", to='ordinal'), "millesimo" ) self.assertEqual( num2words('1234567890123456789012345678', lang="it", to='ordinal'), "un quadriliardo, duecentotrentaquattro quadrilioni, " "cinquecentosessantasette triliardi, ottocentonovanta trilioni, " "centoventitré biliardi, quattrocentocinquantasei bilioni, " "settecentottantanove miliardi, dodici milioni e " "trecentoquarantacinquemilaseicentosettantottesimo" ) def test_currency_eur(self): for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang='it', to='currency', currency='EUR'), test[1] ) def test_currency_usd(self): for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='it', to='currency', currency='USD'), test[1] ) def test_currency_gbp(self): for test in TEST_CASES_TO_CURRENCY_GBP: self.assertEqual( num2words(test[0], lang='it', to='currency', currency='GBP'), test[1] ) num2words-0.5.14/tests/test_ja.py000066400000000000000000000262411473005321200167100ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words from num2words.lang_JA import rendaku_merge_pairs def n2j(*args, **kwargs): return num2words(*args, lang='ja', **kwargs) class Num2WordsJATest(TestCase): def test_low(self): self.assertEqual(n2j(0), "零") self.assertEqual(n2j(0, prefer=["〇"]), "〇") self.assertEqual(n2j(0, reading=True), "ゼロ") self.assertEqual(n2j(0, reading=True, prefer=["れい"]), "れい") self.assertEqual(n2j(1), "一") self.assertEqual(n2j(1, reading=True), "いち") self.assertEqual(n2j(2), "二") self.assertEqual(n2j(2, reading=True), "に") self.assertEqual(n2j(3), "三") self.assertEqual(n2j(3, reading=True), "さん") self.assertEqual(n2j(4), "四") self.assertEqual(n2j(4, reading=True), "よん") self.assertEqual(n2j(4, reading=True, prefer=["し"]), "し") self.assertEqual(n2j(5), "五") self.assertEqual(n2j(5, reading=True), "ご") self.assertEqual(n2j(6), "六") self.assertEqual(n2j(6, reading=True), "ろく") self.assertEqual(n2j(7), "七") self.assertEqual(n2j(7, reading=True), "なな") self.assertEqual(n2j(7, reading=True, prefer=["しち"]), "しち") self.assertEqual(n2j(8), "八") self.assertEqual(n2j(8, reading=True), "はち") self.assertEqual(n2j(9), "九") self.assertEqual(n2j(9, reading=True), "きゅう") self.assertEqual(n2j(10), "十") self.assertEqual(n2j(10, reading=True), "じゅう") self.assertEqual(n2j(11), "十一") self.assertEqual(n2j(11, reading=True), "じゅういち") self.assertEqual(n2j(12), "十二") self.assertEqual(n2j(12, reading=True), "じゅうに") self.assertEqual(n2j(13), "十三") self.assertEqual(n2j(13, reading=True), "じゅうさん") self.assertEqual(n2j(14), "十四") self.assertEqual(n2j(14, reading=True), "じゅうよん") self.assertEqual(n2j(14, reading=True, prefer=["し"]), "じゅうし") self.assertEqual(n2j(15), "十五") self.assertEqual(n2j(15, reading=True), "じゅうご") self.assertEqual(n2j(16), "十六") self.assertEqual(n2j(16, reading=True), "じゅうろく") self.assertEqual(n2j(17), "十七") self.assertEqual(n2j(17, reading=True), "じゅうなな") self.assertEqual(n2j(17, reading=True, prefer=["しち"]), "じゅうしち") self.assertEqual(n2j(18), "十八") self.assertEqual(n2j(18, reading=True), "じゅうはち") self.assertEqual(n2j(19), "十九") self.assertEqual(n2j(19, reading=True), "じゅうきゅう") self.assertEqual(n2j(20), "二十") self.assertEqual(n2j(20, reading=True), "にじゅう") def test_mid(self): self.assertEqual(n2j(100), "百") self.assertEqual(n2j(100, reading=True), "ひゃく") self.assertEqual(n2j(123), "百二十三") self.assertEqual(n2j(123, reading=True), "ひゃくにじゅうさん") self.assertEqual(n2j(300), "三百") self.assertEqual(n2j(300, reading=True), "さんびゃく") self.assertEqual(n2j(400), "四百") self.assertEqual(n2j(400, reading=True), "よんひゃく") # 400 --> しひゃく sounds weird, but can be generated with prefer self.assertEqual(n2j(600), "六百") self.assertEqual(n2j(600, reading=True), "ろっぴゃく") self.assertEqual(n2j(700, reading=True, prefer=["しち"]), "しちひゃく") self.assertEqual(n2j(800, reading=True), "はっぴゃく") self.assertEqual(n2j(1000), "千") self.assertEqual(n2j(1000, reading=True), "せん") self.assertEqual(n2j(3000, reading=True), "さんぜん") self.assertEqual(n2j(8000, reading=True), "はっせん") def test_high(self): self.assertEqual(n2j(10000), "一万") self.assertEqual(n2j(10000, reading=True), "いちまん") self.assertEqual(n2j(12345), "一万二千三百四十五") self.assertEqual(n2j(12345, reading=True), "いちまん" "にせん" "さんびゃく" "よんじゅうご") self.assertEqual(n2j(10**8), "一億") self.assertEqual(n2j(10**8, reading=True), "いちおく") self.assertEqual(n2j(123456789), "一億二千三百四十五万六千七百八十九") self.assertEqual(n2j(123456789, reading=True), "いちおく" "にせんさんびゃくよんじゅうごまん" "ろくせんななひゃく" "はちじゅうきゅう") self.assertEqual(n2j(10**12), "一兆") self.assertEqual(n2j(10**12, reading=True), "いっちょう") self.assertEqual(n2j(1234567890123), "一兆二千三百四十五億六千七百八十九万百二十三") self.assertEqual(n2j(1234567890123, reading=True), "いっちょう" "にせんさんびゃくよんじゅうごおく" "ろくせんななひゃくはちじゅうきゅうまん" "ひゃくにじゅうさん") # TODO: tests for 10**16 and above def test_cardinal_float(self): self.assertEqual(n2j(0.0123456789, prefer=["〇"]), "〇点〇一二三四五六七八九") self.assertEqual(n2j(0.0123456789, reading=True), "れいてん" "れいいち" "にさん" "よんご" "ろくなな" "はちきゅう") self.assertEqual(n2j(10**8 + 0.01), "一億点零一") self.assertEqual(n2j(10**8 + 0.01, reading=True), "いちおくてんれいいち") def test_ordinal(self): self.assertEqual(n2j(0, to="ordinal"), "零番目") self.assertEqual(n2j(0, to="ordinal", reading=True, prefer=["れい"]), "れいばんめ") self.assertEqual(n2j(2, to="ordinal", counter="人"), "二人目") self.assertEqual(n2j(3, to="ordinal", counter="つ"), "三つ目") with self.assertRaises(NotImplementedError): n2j(4, to="ordinal", reading=True, counter="人") def test_ordinal_num(self): self.assertEqual(n2j(0, to="ordinal_num"), "0番目") self.assertEqual(n2j(0, to="ordinal_num", reading=True), "0ばんめ") self.assertEqual(n2j(2, to="ordinal_num", counter="人"), "2人目") self.assertEqual(n2j(3, to="ordinal_num", counter="つ"), "3つ目") def test_currency(self): self.assertEqual(n2j(123456789, to="currency"), "一億二千三百四十五万六千七百八十九円") self.assertEqual(n2j(123456789, to="currency", reading=True), "いちおく" "にせんさんびゃくよんじゅうごまん" "ろくせんななひゃく" "はちじゅうきゅうえん") def test_year(self): self.assertEqual(n2j(2021, to="year"), "令和三年") self.assertEqual(n2j(2021, to="year", reading=True), "れいわさんねん") self.assertEqual(n2j(2021, to="year", reading="arabic"), "令和3年") self.assertEqual(n2j(2019, to="year"), "令和元年") self.assertEqual(n2j(2019, to="year", reading=True), "れいわがんねん") self.assertEqual(n2j(2019, to="year", reading="arabic"), "令和1年") self.assertEqual(n2j(2018, to="year"), "平成三十年") self.assertEqual(n2j(2018, to="year", reading=True), "へいせいさんじゅうねん") self.assertEqual(n2j(2018, to="year", reading="arabic"), "平成30年") self.assertEqual(n2j(2017, to="year"), "平成二十九年") self.assertEqual(n2j(2017, to="year", reading=True), "へいせいにじゅうくねん") self.assertEqual(n2j(2017, to="year", reading="arabic"), "平成29年") self.assertEqual(n2j(2009, to="year", era=False), "二千九年") self.assertEqual(n2j(2009, to="year", reading=True, era=False), "にせんくねん") self.assertEqual(n2j(2000, to="year", era=False), "二千年") self.assertEqual(n2j(2000, to="year", era=False, reading=True), "にせんねん") self.assertEqual(n2j(645, to="year"), "大化元年") self.assertEqual(n2j(645, to="year", reading=True), "たいかがんねん") self.assertEqual(n2j(-99, to="year", era=False), "紀元前九十九年") self.assertEqual(n2j(-99, to="year", era=False, reading=True), "きげんぜんきゅうじゅうくねん") self.assertEqual(n2j(1375, to="year"), "天授元年") self.assertEqual(n2j(1375, to="year", prefer=["えいわ"]), "永和元年") def test_rendaku_merge_pairs(self): self.assertEqual(rendaku_merge_pairs(("はち", 8), ("ちょう", 10**12)), ("はっちょう", 8 * 10**12)) self.assertEqual(rendaku_merge_pairs(("じゅう", 10), ("ちょう", 10**12)), ("じゅっちょう", 10 * 10**12)) self.assertEqual(rendaku_merge_pairs(("いち", 1), ("けい", 10**16)), ("いっけい", 1 * 10**16)) self.assertEqual(rendaku_merge_pairs(("ろく", 6), ("けい", 10**16)), ("ろっけい", 6 * 10**16)) self.assertEqual(rendaku_merge_pairs(("はち", 8), ("けい", 10**16)), ("はっけい", 8 * 10**16)) self.assertEqual(rendaku_merge_pairs(("じゅう", 10), ("けい", 10**16)), ("じゅっけい", 10 * 10**16)) self.assertEqual(rendaku_merge_pairs(("ひゃく", 100), ("けい", 10**16)), ("ひゃっけい", 100 * 10**16)) num2words-0.5.14/tests/test_kn.py000066400000000000000000000070661473005321200167320ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsKNTest(TestCase): def test_numbers(self): self.assertEqual(num2words(42, lang="kn"), u"ನಲವತ್ತ್ ಎರಡು") self.assertEqual(num2words(893, lang="kn"), u"ಎಂಟು ನೂರ ತೊಂಬತ್ತ ಮೂರು") self.assertEqual( num2words(1729, lang="kn"), u"ಒಂದು ಸಾವಿರ ಏಳು ನೂರ ಇಪ್ಪತ್ತ್ಒಂಬತ್ತು" ) self.assertEqual(num2words(123, lang="kn"), u"ಒಂದು ನೂರ ಇಪ್ಪತ್ತ್ ಮೂರು") self.assertEqual(num2words(32211, lang="kn"), u"ಮೂವತ್ತ್ಎರಡು ಸಾವಿರ ಎರಡು ನೂರ ಹನ್ನೊಂದು") def test_cardinal_for_float_number(self): self.assertEqual(num2words(3.14, lang="kn"), u"ಮೂರು ಬಿಂದು ಒಂದು ನಾಲ್ಕು") self.assertEqual(num2words(1.61803, lang="kn"), u"ಒಂದು ಬಿಂದು ಆರು ಒಂದು ಎಂಟು ಸೊನ್ನೆ ಮೂರು") def test_ordinal(self): self.assertEqual( num2words(1, lang='kn', to='ordinal'), u'ಒಂದನೇ' ) self.assertEqual( num2words(22, lang='kn', to='ordinal'), u'ಇಪ್ಪತ್ತ್ ಎರಡನೇ' ) self.assertEqual( num2words(12, lang='kn', to='ordinal'), u'ಹನ್ನೆರಡನೇ' ) self.assertEqual( num2words(130, lang='kn', to='ordinal'), u'ಒಂದು ನೂರ ಮೂವತ್ತನೇ' ) self.assertEqual( num2words(1003, lang='kn', to='ordinal'), u'ಒಂದು ಸಾವಿರದ ಮೂರನೇ' ) self.assertEqual(num2words(2, lang="kn", ordinal=True), u"ಎರಡನೇ") self.assertEqual(num2words(5, lang="kn", ordinal=True), u"ಐದನೇ") self.assertEqual(num2words(16, lang="kn", ordinal=True), u"ಹದಿನಾರನೇ") self.assertEqual(num2words(113, lang="kn", ordinal=True), u"ಒಂದು ನೂರ ಹದಿಮೂರನೇ") def test_ordinal_num(self): self.assertEqual(num2words(2, lang="kn", to='ordinal_num'), u"2ಎರಡನೇ") self.assertEqual(num2words(5, lang="kn", to='ordinal_num'), u"5ಐದನೇ") self.assertEqual(num2words(16, lang="kn", to='ordinal_num'), u"16ಹದಿನಾರನೇ") self.assertEqual(num2words(113, lang="kn", to='ordinal_num'), u"113ಒಂದು ನೂರ ಹದಿಮೂರನೇ") num2words-0.5.14/tests/test_ko.py000066400000000000000000000107031473005321200167230ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words def n2k(*args, **kwargs): return num2words(*args, lang='ko', **kwargs) class Num2WordsKOTest(TestCase): def test_low(self): cases = [(0, "영"), (1, "일"), (2, "이"), (3, "삼"), (4, "사"), (5, "오"), (6, "육"), (7, "칠"), (8, "팔"), (9, "구"), (10, "십"), (11, "십일"), (12, "십이"), (13, "십삼"), (14, "십사"), (15, "십오"), (16, "십육"), (17, "십칠"), (18, "십팔"), (19, "십구"), (20, "이십"), (25, "이십오"), (31, "삼십일"), (42, "사십이"), (54, "오십사"), (63, "육십삼"), (76, "칠십육"), (89, "팔십구"), (98, "구십팔")] for num, out in cases: self.assertEqual(n2k(num), out) def test_mid(self): cases = [(100, "백"), (121, "백이십일"), (160, "백육십"), (256, "이백오십육"), (285, "이백팔십오"), (486, "사백팔십육"), (627, "육백이십칠"), (808, "팔백팔"), (999, "구백구십구"), (1004, "천사"), (2018, "이천십팔"), (7063, "칠천육십삼")] for num, out in cases: self.assertEqual(n2k(num), out) def test_high(self): cases = [(10000, "만"), (11020, "만 천이십"), (25891, "이만 오천팔백구십일"), (64237, "육만 사천이백삼십칠"), (241572, "이십사만 천오백칠십이"), (100000000, "일억"), (5000500000000, "오조 오억")] for num, out in cases: self.assertEqual(n2k(num), out) def test_negative(self): cases = [(-11, "마이너스 십일"), (-15, "마이너스 십오"), (-18, "마이너스 십팔"), (-241572, "마이너스 이십사만 천오백칠십이")] for num, out in cases: self.assertEqual(n2k(num), out) def test_year(self): cases = [(2000, "이천년"), (2002, "이천이년"), (2018, "이천십팔년"), (1954, "천구백오십사년"), (1910, "천구백십년"), (-1000, "기원전 천년")] for num, out in cases: self.assertEqual(n2k(num, to="year"), out) def test_currency(self): cases_krw = [(8350, "팔천삼백오십원"), (14980, "만사천구백팔십원"), (250004000, "이억오천만사천원")] cases_usd = [(4, "사달러 영센트"), (19.55, "십구달러 오십오센트")] cases_jpy = [(15, "십오엔"), (50, "오십엔")] for num, out in cases_krw: self.assertEqual(n2k(num, to="currency"), out) for num, out in cases_usd: self.assertEqual(n2k(num, to="currency", currency="USD"), out) for num, out in cases_jpy: self.assertEqual(n2k(num, to="currency", currency="JPY"), out) with self.assertRaises(ValueError): n2k(190.55, to="currency") with self.assertRaises(NotImplementedError): n2k(4, to="currency", currency="EUR") def test_ordinal(self): cases = [(1, "첫 번째"), (101, "백 한 번째"), (2, "두 번째"), (5, "다섯 번째"), (10, "열 번째"), (25, "스물다섯 번째"), (137, "백 서른일곱 번째")] for num, out in cases: self.assertEqual(n2k(num, to="ordinal"), out) def test_ordinal_num(self): cases = [(1, "1 번째"), (101, "101 번째"), (25, "25 번째")] for num, out in cases: self.assertEqual(n2k(num, to="ordinal_num"), out) num2words-0.5.14/tests/test_kz.py000066400000000000000000000071431473005321200167420ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsKZTest(TestCase): def test_to_cardinal(self): self.maxDiff = None self.assertEqual(num2words(7, lang="kz"), "жеті") self.assertEqual(num2words(23, lang="kz"), "жиырма үш") self.assertEqual(num2words(145, lang="kz"), "жүз қырық бес") self.assertEqual( num2words(2869, lang="kz"), "екі мың сегіз жүз алпыс тоғыз" ) self.assertEqual( num2words(-789000125, lang="kz"), "минус жеті жүз сексен тоғыз миллион жүз жиырма бес", ) self.assertEqual( num2words(84932, lang="kz"), "сексен төрт мың тоғыз жүз отыз екі" ) def test_to_cardinal_floats(self): self.assertEqual(num2words(100.67, lang="kz"), "жүз бүтін алпыс жеті") self.assertEqual(num2words(0.7, lang="kz"), "нөл бүтін жеті") self.assertEqual(num2words(1.73, lang="kz"), "бір бүтін жетпіс үш") self.assertEqual( num2words(10.02, lang='kz'), "он бүтін нөл екі" ) self.assertEqual( num2words(15.007, lang='kz'), "он бес бүтін нөл нөл жеті" ) def test_to_ordinal(self): with self.assertRaises(NotImplementedError): num2words(1, lang="kz", to="ordinal") def test_to_currency(self): self.assertEqual( num2words(25.24, lang="kz", to="currency", currency="KZT"), "жиырма бес теңге, жиырма төрт тиын", ) self.assertEqual( num2words(1996.4, lang="kz", to="currency", currency="KZT"), "бір мың тоғыз жүз тоқсан алты теңге, қырық тиын", ) self.assertEqual( num2words(632924.51, lang="kz", to="currency", currency="KZT"), "алты жүз отыз екі мың тоғыз жүз жиырма төрт теңге, елу бір тиын", ) self.assertEqual( num2words(632924.513, lang="kz", to="currency", currency="KZT"), "алты жүз отыз екі мың тоғыз жүз жиырма төрт теңге, елу бір тиын", ) self.assertEqual( num2words(987654321.123, lang="kz", to="currency", currency="KZT"), "тоғыз жүз сексен жеті миллион алты жүз елу төрт мың " "үш жүз жиырма бір теңге, он екі тиын", ) num2words-0.5.14/tests/test_lt.py000066400000000000000000000173711473005321200167410ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsLTTest(TestCase): def test_to_cardinal(self): self.assertEqual(num2words(100, lang='lt'), 'vienas šimtas') self.assertEqual(num2words(101, lang='lt'), 'vienas šimtas vienas') self.assertEqual(num2words(110, lang='lt'), 'vienas šimtas dešimt') self.assertEqual(num2words(115, lang='lt'), 'vienas šimtas penkiolika') self.assertEqual(num2words(123, lang='lt'), 'vienas šimtas dvidešimt trys') self.assertEqual(num2words(1000, lang='lt'), 'vienas tūkstantis') self.assertEqual(num2words(1001, lang='lt'), 'vienas tūkstantis vienas') self.assertEqual(num2words(2012, lang='lt'), 'du tūkstančiai dvylika') self.assertEqual( num2words(1234567890, lang='lt'), "vienas milijardas du šimtai trisdešimt keturi milijonai " "penki šimtai šešiasdešimt septyni tūkstančiai aštuoni šimtai " "devyniasdešimt") self.assertEqual( num2words(215461407892039002157189883901676, lang='lt'), "du šimtai penkiolika naintilijonų keturi šimtai šešiasdešimt " "vienas oktilijonas keturi šimtai septyni septilijonai aštuoni " "šimtai devyniasdešimt du sikstilijonai trisdešimt devyni " "kvintilijonai du kvadrilijonai vienas šimtas penkiasdešimt " "septyni trilijonai vienas šimtas aštuoniasdešimt devyni " "milijardai aštuoni šimtai aštuoniasdešimt trys milijonai " "devyni šimtai vienas tūkstantis šeši šimtai " "septyniasdešimt šeši") self.assertEqual( num2words(719094234693663034822824384220291, lang='lt'), "septyni šimtai devyniolika naintilijonų devyniasdešimt keturi " "oktilijonai du šimtai trisdešimt keturi septilijonai šeši " "šimtai devyniasdešimt trys sikstilijonai šeši šimtai " "šešiasdešimt trys kvintilijonai trisdešimt keturi kvadrilijonai " "aštuoni šimtai dvidešimt du trilijonai aštuoni šimtai dvidešimt " "keturi milijardai trys šimtai aštuoniasdešimt keturi milijonai " "du šimtai dvidešimt tūkstančių du šimtai devyniasdešimt vienas") self.assertEqual( num2words(-5000, lang='lt'), 'minus penki tūkstančiai', ) self.assertEqual( num2words(-5000.22, lang='lt'), 'minus penki tūkstančiai kablelis dvidešimt du', ) self.assertEqual( num2words(10.02, lang='lt'), "dešimt kablelis nulis du" ) self.assertEqual( num2words(15.007, lang='lt'), "penkiolika kablelis nulis nulis septyni" ) def test_to_ordinal(self): # @TODO: implement to_ordinal with self.assertRaises(NotImplementedError): num2words(1, lang='lt', to='ordinal') def test_to_currency(self): # Test all available currency forms. # LTL self.assertEqual( num2words(1.0, lang='lt', to='currency', currency='LTL'), 'vienas litas, nulis centų' ) self.assertEqual( num2words(10.01, lang='lt', to='currency', currency='LTL'), 'dešimt litų, vienas centas' ) self.assertEqual( num2words(1234.56, lang='lt', to='currency', currency='LTL'), 'vienas tūkstantis du šimtai trisdešimt keturi litai, ' 'penkiasdešimt šeši centai' ) # EUR self.assertEqual( num2words(-1251981, lang='lt', to='currency', currency='EUR', cents=False), 'minus dvylika tūkstančių penki šimtai devyniolika eurų, ' '81 centas' ) self.assertEqual( num2words(1.0, lang='lt', to='currency', currency='EUR'), 'vienas euras, nulis centų' ) self.assertEqual( num2words(1234.56, lang='lt', to='currency', currency='EUR'), 'vienas tūkstantis du šimtai trisdešimt keturi eurai, ' 'penkiasdešimt šeši centai' ) self.assertEqual( num2words(1122.22, lang='lt', to='currency', currency='EUR'), 'vienas tūkstantis vienas šimtas dvidešimt du eurai, ' 'dvidešimt du centai' ) # USD self.assertEqual( num2words(-1281, lang='lt', to='currency', currency='USD', cents=False), 'minus dvylika dolerių, 81 centas' ) self.assertEqual( num2words(1.0, lang='lt', to='currency', currency='USD'), 'vienas doleris, nulis centų' ) self.assertEqual( num2words(5.06, lang='lt', to='currency', currency='USD'), 'penki doleriai, šeši centai' ) # GBP self.assertEqual( num2words(-1281, lang='lt', to='currency', currency='GBP', cents=False), 'minus dvylika svarų sterlingų, 81 pensas' ) self.assertEqual( num2words(1.0, lang='lt', to='currency', currency='GBP'), 'vienas svaras sterlingų, nulis pensų' ) self.assertEqual( num2words(5.06, lang='lt', to='currency', currency='GBP'), 'penki svarai sterlingų, šeši pensai' ) # PLN self.assertEqual( num2words(-1281, lang='lt', to='currency', currency='PLN', cents=False), 'minus dvylika zlotų, 81 grašis' ) self.assertEqual( num2words(1.0, lang='lt', to='currency', currency='PLN'), 'vienas zlotas, nulis grašių' ) self.assertEqual( num2words(5.06, lang='lt', to='currency', currency='PLN'), 'penki zlotai, šeši grašiai' ) # RUB self.assertEqual( num2words(-1281, lang='lt', to='currency', currency='RUB', cents=False), 'minus dvylika rublių, 81 kapeika' ) self.assertEqual( num2words(1.0, lang='lt', to='currency', currency='RUB'), 'vienas rublis, nulis kapeikų' ) self.assertEqual( num2words(5.06, lang='lt', to='currency', currency='RUB'), 'penki rubliai, šešios kapeikos' ) self.assertEqual( num2words(-12.01, lang='lt', to='currency', currency='RUB'), 'minus dvylika rublių, viena kapeika' ) self.assertEqual( num2words(1122.22, lang='lt', to='currency', currency='RUB'), 'vienas tūkstantis vienas šimtas dvidešimt du rubliai, ' 'dvidešimt dvi kapeikos' ) num2words-0.5.14/tests/test_lv.py000066400000000000000000000155321473005321200167400ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsLVTest(TestCase): def test_to_cardinal(self): self.assertEqual(num2words(100, lang='lv'), 'simts') self.assertEqual(num2words(101, lang='lv'), 'simtu viens') self.assertEqual(num2words(110, lang='lv'), 'simts desmit') self.assertEqual(num2words(115, lang='lv'), 'simts piecpadsmit') self.assertEqual(num2words(123, lang='lv'), 'simts divdesmit trīs') self.assertEqual(num2words(1000, lang='lv'), 'tūkstotis') self.assertEqual(num2words(1001, lang='lv'), 'tūkstotis viens') self.assertEqual(num2words(2012, lang='lv'), 'divi tūkstoši divpadsmit') self.assertEqual( num2words(1234567890, lang='lv'), 'miljards divi simti trīsdesmit četri miljoni pieci simti ' 'sešdesmit septiņi tūkstoši astoņi simti deviņdesmit') self.assertEqual( num2words(215461407892039002157189883901676, lang='lv'), 'divi simti piecpadsmit nontiljoni četri simti sešdesmit ' 'viens oktiljons četri simti septiņi septiljoni astoņi ' 'simti deviņdesmit divi sikstiljoni trīsdesmit deviņi ' 'kvintiljoni divi kvadriljoni simts piecdesmit septiņi ' 'triljoni simts astoņdesmit deviņi miljardi astoņi simti ' 'astoņdesmit trīs miljoni deviņi simti viens tūkstotis ' 'seši simti septiņdesmit seši') self.assertEqual( num2words(719094234693663034822824384220291, lang='lv'), 'septiņi simti deviņpadsmit nontiljoni deviņdesmit četri ' 'oktiljoni divi simti trīsdesmit četri septiljoni seši simti ' 'deviņdesmit trīs sikstiljoni seši simti sešdesmit trīs ' 'kvintiljoni trīsdesmit četri kvadriljoni astoņi simti ' 'divdesmit divi triljoni astoņi simti divdesmit četri ' 'miljardi trīs simti astoņdesmit četri miljoni divi simti ' 'divdesmit tūkstoši divi simti deviņdesmit viens') self.assertEqual( num2words(-5000, lang='lv'), 'mīnus pieci tūkstoši', ) self.assertEqual( num2words(-5000.22, lang='lv'), 'mīnus pieci tūkstoši komats divdesmit divi', ) self.assertEqual( num2words(10.02, lang='lv'), "desmit komats nulle divi" ) self.assertEqual( num2words(15.007, lang='lv'), "piecpadsmit komats nulle nulle septiņi" ) self.assertEqual(num2words(0, lang='lv'), 'nulle') self.assertEqual(num2words(5, lang='lv'), "pieci") self.assertEqual(num2words(15, lang='lv'), "piecpadsmit") self.assertEqual(num2words(154, lang='lv'), "simts piecdesmit četri") self.assertEqual(num2words(101, lang='lv'), "simtu viens") self.assertEqual( num2words(1135, lang='lv'), "tūkstotis simts trīsdesmit pieci" ) self.assertEqual( num2words(418531, lang='lv'), "četri simti astoņpadsmit tūkstoši pieci simti trīsdesmit viens" ) self.assertEqual( num2words(1000139, lang='lv'), "miljons simts trīsdesmit deviņi" ) def test_to_ordinal(self): # @TODO: implement to_ordinal with self.assertRaises(NotImplementedError): num2words(1, lang='lv', to='ordinal') def test_to_currency(self): self.assertEqual( num2words(1.0, lang='lv', to='currency', currency='EUR'), "viens eiro, nulle centu" ) self.assertEqual( num2words(1.0, lang='lv', to='currency', currency='LVL'), "viens lats, nulle santīmu" ) self.assertEqual( num2words(1234.56, lang='lv', to='currency', currency='EUR'), "tūkstotis divi simti trīsdesmit četri eiro, piecdesmit seši centi" ) self.assertEqual( num2words(1234.56, lang='lv', to='currency', currency='LVL'), "tūkstotis divi simti trīsdesmit četri lati, " "piecdesmit seši santīmi" ) self.assertEqual( num2words(10111, lang='lv', to='currency', separator=' un', currency='EUR'), "simtu viens eiro un vienpadsmit centi" ) self.assertEqual( num2words(10121, lang='lv', to='currency', separator=' un', currency='LVL'), "simtu viens lats un divdesmit viens santīms" ) self.assertEqual( num2words(-1251985, lang='lv', to='currency', cents=False, currency='EUR'), "mīnus divpadsmit tūkstoši pieci simti deviņpadsmit eiro," " 85 centi" ) self.assertEqual( num2words('38.4', lang='lv', to='currency', separator=' un', cents=False, currency='EUR'), "trīsdesmit astoņi eiro un 40 centi" ) # EUR legal form self.assertEqual( num2words('38.4', lang='lv', to='currency', separator=' un', cents=False, currency='EUR_LEGAL'), "trīsdesmit astoņi euro un 40 centi" ) self.assertEqual( num2words('38.4', lang='lv', to='currency', separator=' un', cents=False, currency='USD', adjective=False), "trīsdesmit astoņi dolāri un 40 centi" ) self.assertEqual( num2words('38.4', lang='lv', to='currency', separator=' un', cents=False, currency='USD', adjective=True), "trīsdesmit astoņi ASV dolāri un 40 centi" ) def test_fractions(self): self.assertEqual(num2words(5.2, lang='lv'), "pieci komats divi") self.assertEqual( num2words(561.42, lang='lv'), "pieci simti sešdesmit viens komats četrdesmit divi" ) num2words-0.5.14/tests/test_nl.py000066400000000000000000000122601473005321200167230ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words from num2words.lang_NL import Num2Word_NL class Num2WordsNLTest(TestCase): def test_ordinal_less_than_twenty(self): self.assertEqual(num2words(7, ordinal=True, lang='nl'), "zevende") self.assertEqual(num2words(8, ordinal=True, lang='nl'), "achtste") self.assertEqual(num2words(12, ordinal=True, lang='nl'), "twaalfde") self.assertEqual(num2words(17, ordinal=True, lang='nl'), "zeventiende") def test_ordinal_more_than_twenty(self): self.assertEqual( num2words(81, ordinal=True, lang='nl'), "eenentachtigste" ) def test_ordinal_at_crucial_number(self): self.assertEqual(num2words(0, ordinal=True, lang='nl'), "nulde") self.assertEqual(num2words(100, ordinal=True, lang='nl'), "honderdste") self.assertEqual( num2words(1000, ordinal=True, lang='nl'), "duizendste" ) self.assertEqual( num2words(4000, ordinal=True, lang='nl'), "vierduizendste" ) self.assertEqual( num2words(2000000, ordinal=True, lang='nl'), "twee miljoenste" ) self.assertEqual( num2words(5000000000, ordinal=True, lang='nl'), "vijf miljardste" ) def test_cardinal_at_some_numbers(self): self.assertEqual(num2words(82, lang='nl'), u'twee\xebntachtig') self.assertEqual(num2words(1013, lang='nl'), "duizenddertien") self.assertEqual(num2words(2000000, lang='nl'), "twee miljoen") self.assertEqual(num2words(4000000000, lang='nl'), "vier miljard") def test_cardinal_for_decimal_number(self): self.assertEqual( num2words(3.486, lang='nl'), "drie komma vier acht zes" ) def test_ordinal_for_negative_numbers(self): self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='nl') def test_ordinal_for_floating_numbers(self): self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='nl') def test_to_currency_eur(self): self.assertEqual( num2words('38.4', lang='nl', to='currency', separator=' en', cents=False, currency='EUR'), "achtendertig euro en 40 cent" ) self.assertEqual( num2words('0', lang='nl', to='currency', separator=' en', cents=False, currency='EUR'), "nul euro en 00 cent" ) self.assertEqual( num2words('1.01', lang='nl', to='currency', separator=' en', cents=True, currency='EUR'), "één euro en één cent" ) self.assertEqual( num2words('4778.00', lang='nl', to='currency', separator=' en', cents=True, currency='EUR'), 'vierduizendzevenhonderdachtenzeventig euro en nul cent') def test_to_currency_usd(self): self.assertEqual( num2words('38.4', lang='nl', to='currency', separator=' en', cents=False, currency='USD'), "achtendertig dollar en 40 cent" ) self.assertEqual( num2words('0', lang='nl', to='currency', separator=' en', cents=False, currency='USD'), "nul dollar en 00 cent" ) self.assertEqual( num2words('1.01', lang='nl', to='currency', separator=' en', cents=True, currency='USD'), "één dollar en één cent" ) self.assertEqual( num2words('4778.00', lang='nl', to='currency', separator=' en', cents=True, currency='USD'), 'vierduizendzevenhonderdachtenzeventig dollar en nul cent') def test_pluralize(self): n = Num2Word_NL() # euros always singular cr1, cr2 = n.CURRENCY_FORMS['EUR'] self.assertEqual(n.pluralize(1, cr1), 'euro') self.assertEqual(n.pluralize(2, cr1), 'euro') self.assertEqual(n.pluralize(1, cr2), 'cent') self.assertEqual(n.pluralize(2, cr2), 'cent') # @TODO other currency def test_to_year(self): self.assertEqual(num2words(2018, lang='nl', to='year'), 'tweeduizendachttien') self.assertEqual(num2words(2100, lang='nl', to='year'), 'eenentwintig honderd') num2words-0.5.14/tests/test_no.py000066400000000000000000000107371473005321200167350ustar00rootroot00000000000000# 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 unittest import TestCase from num2words import num2words class Num2WordsNOTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(0, to="cardinal", lang="no"), "null") self.assertEqual(num2words(1, to="cardinal", lang="no"), "en") self.assertEqual(num2words(3, to="cardinal", lang="no"), "tre") self.assertEqual(num2words(5, to="cardinal", lang="no"), "fem") self.assertEqual(num2words(18, to="cardinal", lang="no"), "atten") self.assertEqual(num2words(45, to="cardinal", lang="no"), "førtifem") self.assertEqual(num2words(92, to="cardinal", lang="no"), "nittito") self.assertEqual(num2words(1345, to="cardinal", lang="no"), "en tusen tre hundre og førtifem") self.assertEqual(num2words(4435, to="cardinal", lang="no"), "fire tusen fire hundre og trettifem") self.assertEqual(num2words(1004435, to="cardinal", lang="no"), "en million fire tusen fire hundre og trettifem") self.assertEqual(num2words(4335000, to="cardinal", lang="no"), "fire million tre hundre og trettifem tusen") self.assertEqual(num2words(14004535, to="cardinal", lang="no"), "fjorten million fire tusen fem hundre og trettifem") self.assertEqual(num2words(1.5, to="cardinal", lang="no"), "en komma fem") def test_ordinal(self): self.assertEqual(num2words(1, to="ordinal", lang="no"), "første") self.assertEqual(num2words(5, to="ordinal", lang="no"), "femte") self.assertEqual(num2words(10, to="ordinal", lang="no"), "tiende") self.assertEqual(num2words(14, to="ordinal", lang="no"), "fjortende") self.assertEqual(num2words(30, to="ordinal", lang="no"), "trettiende") self.assertEqual(num2words(32, to="ordinal", lang="no"), "trettiandre") self.assertEqual(num2words(100, to="ordinal", lang="no"), "en hundrede") self.assertEqual(num2words(1000, to="ordinal", lang="no"), "en tusende") self.assertEqual(num2words(1435, to="ordinal", lang="no"), "en tusen fire hundre og trettifemte") self.assertEqual(num2words(1000000, to="ordinal", lang="no"), "en millionte") def test_ordinal_num(self): self.assertEqual(num2words(1, to="ordinal_num", lang="no"), "1.") self.assertEqual(num2words(5, to="ordinal_num", lang="no"), "5.") self.assertEqual(num2words(10, to="ordinal_num", lang="no"), "10.") self.assertEqual(num2words(14, to="ordinal_num", lang="no"), "14.") self.assertEqual(num2words(32, to="ordinal_num", lang="no"), "32.") def test_year(self): self.assertEqual(num2words(1835, to="year", lang="no"), "atten hundre og trettifem") self.assertEqual(num2words(2015, to="year", lang="no"), "to tusen og femten") def test_currency(self): self.assertEqual(num2words(1.00, to="currency", lang="no"), "en krone") self.assertEqual(num2words(2.00, to="currency", lang="no"), "to kroner") self.assertEqual(num2words(2.50, to="currency", lang="no"), "to kroner og femti øre") self.assertEqual(num2words(135.00, to="currency", lang="no"), "en hundre og trettifem kroner") self.assertEqual(num2words(135.59, to="currency", lang="no"), "en hundre og trettifem kroner og femtini øre") num2words-0.5.14/tests/test_pl.py000066400000000000000000000177101473005321200167320ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsPLTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(90, lang='pl'), "dziewięćdziesiąt") self.assertEqual(num2words(100, lang='pl'), "sto") self.assertEqual(num2words(101, lang='pl'), "sto jeden") self.assertEqual(num2words(110, lang='pl'), "sto dziesięć") self.assertEqual(num2words(115, lang='pl'), "sto piętnaście") self.assertEqual(num2words(123, lang='pl'), "sto dwadzieścia trzy") self.assertEqual(num2words(400, lang='pl'), "czterysta") self.assertEqual(num2words(1000, lang='pl'), "tysiąc") self.assertEqual(num2words(1001, lang='pl'), "tysiąc jeden") self.assertEqual(num2words(2012, lang='pl'), "dwa tysiące dwanaście") self.assertEqual( num2words(10.02, lang='pl'), "dziesięć przecinek zero dwa" ) self.assertEqual( num2words(15.007, lang='pl'), "piętnaście przecinek zero zero siedem" ) self.assertEqual( num2words(12519.85, lang='pl'), "dwanaście tysięcy pięćset dziewiętnaście przecinek " "osiemdziesiąt pięć" ) self.assertEqual( num2words(123.50, lang='pl'), "sto dwadzieścia trzy przecinek pięć" ) self.assertEqual( num2words(1234567890, lang='pl'), "miliard dwieście trzydzieści cztery miliony pięćset " "sześćdziesiąt siedem tysięcy osiemset dziewięćdziesiąt" ) self.assertEqual( num2words(10000000001000000100000, lang='pl'), "dziesięć tryliardów bilion sto tysięcy" ) self.assertEqual( num2words(215461407892039002157189883901676, lang='pl'), "dwieście piętnaście kwintylionów czterysta sześćdziesiąt jeden " "kwadryliardów czterysta siedem kwadrylionów osiemset " "dziewięćdziesiąt dwa tryliardy trzydzieści dziewięć trylionów " "dwa biliardy sto pięćdziesiąt siedem bilionów sto osiemdziesiąt " "dziewięć miliardów osiemset osiemdziesiąt trzy miliony " "dziewięćset jeden tysięcy sześćset siedemdziesiąt sześć" ) self.assertEqual( num2words(719094234693663034822824384220291, lang='pl'), "siedemset dziewiętnaście kwintylionów dziewięćdziesiąt cztery " "kwadryliardy dwieście trzydzieści cztery kwadryliony sześćset " "dziewięćdziesiąt trzy tryliardy sześćset sześćdziesiąt trzy " "tryliony trzydzieści cztery biliardy osiemset dwadzieścia dwa " "biliony osiemset dwadzieścia cztery miliardy trzysta " "osiemdziesiąt cztery miliony dwieście dwadzieścia " "tysięcy dwieście dziewięćdziesiąt jeden" ) self.assertEqual( num2words( 963301000001918264129471001047146102 * 10**30 + 1007, lang='pl' ), "dziewięćset sześćdziesiąt trzy decyliardy trzysta jeden " "decylionów nonylion dziewięćset osiemnaście oktyliardów dwieście " "sześćdziesiąt cztery oktyliony sto dwadzieścia dziewięć " "septyliardów czterysta siedemdziesiąt jeden septylionów " "sekstyliard czterdzieści siedem sekstylionów sto czterdzieści " "sześć kwintyliardów sto dwa kwintyliony tysiąc siedem" ) def test_to_ordinal(self): self.assertEqual(num2words(100, lang='pl', to='ordinal'), "setny") self.assertEqual( num2words(101, lang='pl', to='ordinal'), "sto pierwszy") self.assertEqual(num2words(120, lang='pl', to='ordinal'), "sto dwudziesty") self.assertEqual(num2words(20, lang='pl', to='ordinal'), "dwudziesty") self.assertEqual(num2words(121, lang='pl', to='ordinal'), "sto dwudziesty pierwszy") self.assertEqual( num2words(115, lang='pl', to='ordinal'), "sto piętnasty") self.assertEqual( num2words(25, lang='pl', to='ordinal'), "dwudziesty piąty") self.assertEqual(num2words(1021, lang='pl', to='ordinal'), "tysiąc dwudziesty pierwszy") self.assertEqual( num2words(120, lang='pl', to='ordinal'), "sto dwudziesty") self.assertEqual(num2words(1000021, lang='pl', to='ordinal'), "milion dwudziesty pierwszy") self.assertEqual(num2words(1000, lang='pl', to='ordinal'), "tysięczny") self.assertEqual(num2words(10000, lang='pl', to='ordinal'), "dziesięciotysięczny") self.assertEqual(num2words(100000000, lang='pl', to='ordinal'), "stumilionowy") self.assertEqual(num2words(1002000, lang='pl', to='ordinal'), "milion dwutysięczny") self.assertEqual(num2words(1001000, lang='pl', to='ordinal'), "milion tysięczny") self.assertEqual(num2words(1000000, lang='pl', to='ordinal'), "milionowy") def test_to_ordinal_error(self): with self.assertRaises(NotImplementedError): num2words(1.5, lang='pl', to='ordinal') def test_currency(self): self.assertEqual( num2words(1.0, lang='pl', to='currency', currency='EUR'), "jeden euro, zero centów") self.assertEqual( num2words(1.0, lang='pl', to='currency', currency='PLN'), "jeden złoty, zero groszy") self.assertEqual( num2words(1234.56, lang='pl', to='currency', currency='EUR'), "tysiąc dwieście trzydzieści cztery euro, pięćdziesiąt sześć " "centów" ) self.assertEqual( num2words(1234.56, lang='pl', to='currency', currency='PLN'), "tysiąc dwieście trzydzieści cztery złote, pięćdziesiąt sześć " "groszy" ) self.assertEqual( num2words(10111, lang='pl', to='currency', currency='EUR', separator=' i'), "sto jeden euro i jedenaście centów" ) self.assertEqual( num2words(10121, lang='pl', to='currency', currency='PLN', separator=' i'), "sto jeden złotych i dwadzieścia jeden groszy" ) self.assertEqual( num2words(-1251985, lang='pl', to='currency', cents=False), "minus dwanaście tysięcy pięćset dziewiętnaście euro, 85 centów" ) self.assertEqual( num2words(123.50, lang='pl', to='currency', currency='PLN', separator=' i'), "sto dwadzieścia trzy złote i pięćdziesiąt groszy" ) self.assertEqual( num2words(1950, lang='pl', to='currency', cents=False), "dziewiętnaście euro, 50 centów" ) num2words-0.5.14/tests/test_pt.py000066400000000000000000000437731473005321200167520ustar00rootroot00000000000000# -*- 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 decimal import Decimal from unittest import TestCase from num2words import num2words from num2words.lang_PT import Num2Word_PT class Num2WordsPTTest(TestCase): def setUp(self): super(Num2WordsPTTest, self).setUp() self.n2w = Num2Word_PT() def test_cardinal_integer(self): self.assertEqual(num2words(1, lang='pt'), 'um') self.assertEqual(num2words(2, lang='pt'), 'dois') self.assertEqual(num2words(3, lang='pt'), 'três') self.assertEqual(num2words(4, lang='pt'), 'quatro') self.assertEqual(num2words(5, lang='pt'), 'cinco') self.assertEqual(num2words(6, lang='pt'), 'seis') self.assertEqual(num2words(7, lang='pt'), 'sete') self.assertEqual(num2words(8, lang='pt'), 'oito') self.assertEqual(num2words(9, lang='pt'), 'nove') self.assertEqual(num2words(10, lang='pt'), 'dez') self.assertEqual(num2words(11, lang='pt'), 'onze') self.assertEqual(num2words(12, lang='pt'), 'doze') self.assertEqual(num2words(13, lang='pt'), 'treze') self.assertEqual(num2words(14, lang='pt'), 'catorze') self.assertEqual(num2words(15, lang='pt'), 'quinze') self.assertEqual(num2words(16, lang='pt'), 'dezasseis') self.assertEqual(num2words(17, lang='pt'), 'dezassete') self.assertEqual(num2words(18, lang='pt'), 'dezoito') self.assertEqual(num2words(19, lang='pt'), 'dezanove') self.assertEqual(num2words(20, lang='pt'), 'vinte') self.assertEqual(num2words(21, lang='pt'), 'vinte e um') self.assertEqual(num2words(22, lang='pt'), 'vinte e dois') self.assertEqual(num2words(35, lang='pt'), 'trinta e cinco') self.assertEqual(num2words(99, lang='pt'), 'noventa e nove') self.assertEqual(num2words(100, lang='pt'), 'cem') self.assertEqual(num2words(101, lang='pt'), 'cento e um') self.assertEqual(num2words(128, lang='pt'), 'cento e vinte e oito') self.assertEqual(num2words(713, lang='pt'), 'setecentos e treze') self.assertEqual(num2words(1000, lang='pt'), 'mil') self.assertEqual(num2words(1001, lang='pt'), 'mil e um') self.assertEqual(num2words(1111, lang='pt'), 'mil cento e onze') self.assertEqual( num2words(2114, lang='pt'), 'dois mil cento e catorze' ) self.assertEqual( num2words(2200, lang='pt'), 'dois mil e duzentos' ) self.assertEqual( num2words(2230, lang='pt'), 'dois mil duzentos e trinta' ) self.assertEqual( num2words(73400, lang='pt'), 'setenta e três mil e quatrocentos' ) self.assertEqual( num2words(73421, lang='pt'), 'setenta e três mil quatrocentos e vinte e um' ) self.assertEqual(num2words(100000, lang='pt'), 'cem mil') self.assertEqual( num2words(250050, lang='pt'), 'duzentos e cinquenta mil e cinquenta' ) self.assertEqual( num2words(6000000, lang='pt'), 'seis milhões' ) self.assertEqual( num2words(100000000, lang='pt'), 'cem milhões' ) self.assertEqual( num2words(19000000000, lang='pt'), 'dezanove mil milhões' ) self.assertEqual( num2words(145000000002, lang='pt'), 'cento e quarenta e cinco mil milhões e dois' ) self.assertEqual( num2words(4635102, lang='pt'), 'quatro milhões seiscentos e trinta e cinco mil cento e dois' ) self.assertEqual( num2words(145254635102, lang='pt'), 'cento e quarenta e cinco mil duzentos e cinquenta e quatro ' 'milhões seiscentos e trinta e cinco mil cento e dois' ) self.assertEqual( num2words(1000000000000, lang='pt'), 'um bilião' ) self.assertEqual( num2words(2000000000000, lang='pt'), 'dois biliões' ) self.assertEqual( num2words(1000000000000000, lang='pt'), 'mil biliões' ) self.assertEqual( num2words(2000000000000000, lang='pt'), 'dois mil biliões' ) self.assertEqual( num2words(1000000000000000000, lang='pt'), 'um trilião' ) self.assertEqual( num2words(2000000000000000000, lang='pt'), 'dois triliões' ) def test_cardinal_integer_negative(self): self.assertEqual(num2words(-1, lang='pt'), 'menos um') self.assertEqual( num2words(-256, lang='pt'), 'menos duzentos e cinquenta e seis' ) self.assertEqual(num2words(-1000, lang='pt'), 'menos mil') self.assertEqual(num2words(-1000000, lang='pt'), 'menos um milhão') self.assertEqual( num2words(-1234567, lang='pt'), 'menos um milhão duzentos e trinta e quatro mil quinhentos e ' 'sessenta e sete' ) def test_cardinal_float(self): self.assertEqual(num2words(Decimal('1.00'), lang='pt'), 'um') self.assertEqual(num2words( Decimal('1.01'), lang='pt'), 'um vírgula zero um') self.assertEqual(num2words( Decimal('1.035'), lang='pt'), 'um vírgula zero três cinco' ) self.assertEqual(num2words( Decimal('1.35'), lang='pt'), 'um vírgula três cinco' ) self.assertEqual( num2words(Decimal('3.14159'), lang='pt'), 'três vírgula um quatro um cinco nove' ) self.assertEqual( num2words(Decimal('101.22'), lang='pt'), 'cento e um vírgula dois dois' ) self.assertEqual( num2words(Decimal('2345.75'), lang='pt'), 'dois mil trezentos e quarenta e cinco vírgula sete cinco') def test_cardinal_float_negative(self): self.assertEqual( num2words(Decimal('-2.34'), lang='pt'), 'menos dois vírgula três quatro' ) self.assertEqual( num2words(Decimal('-9.99'), lang='pt'), 'menos nove vírgula nove nove' ) self.assertEqual( num2words(Decimal('-7.01'), lang='pt'), 'menos sete vírgula zero um' ) self.assertEqual( num2words(Decimal('-222.22'), lang='pt'), 'menos duzentos e vinte e dois vírgula dois dois' ) def test_ordinal(self): self.assertEqual(num2words(1, lang='pt', ordinal=True), 'primeiro') self.assertEqual(num2words(2, lang='pt', ordinal=True), 'segundo') self.assertEqual(num2words(3, lang='pt', ordinal=True), 'terceiro') self.assertEqual(num2words(4, lang='pt', ordinal=True), 'quarto') self.assertEqual(num2words(5, lang='pt', ordinal=True), 'quinto') self.assertEqual(num2words(6, lang='pt', ordinal=True), 'sexto') self.assertEqual(num2words(7, lang='pt', ordinal=True), 'sétimo') self.assertEqual(num2words(8, lang='pt', ordinal=True), 'oitavo') self.assertEqual(num2words(9, lang='pt', ordinal=True), 'nono') self.assertEqual(num2words(10, lang='pt', ordinal=True), 'décimo') self.assertEqual( num2words(11, lang='pt', ordinal=True), 'décimo primeiro' ) self.assertEqual( num2words(12, lang='pt', ordinal=True), 'décimo segundo' ) self.assertEqual( num2words(13, lang='pt', ordinal=True), 'décimo terceiro' ) self.assertEqual( num2words(14, lang='pt', ordinal=True), 'décimo quarto' ) self.assertEqual( num2words(15, lang='pt', ordinal=True), 'décimo quinto' ) self.assertEqual( num2words(16, lang='pt', ordinal=True), 'décimo sexto' ) self.assertEqual( num2words(17, lang='pt', ordinal=True), 'décimo sétimo' ) self.assertEqual( num2words(18, lang='pt', ordinal=True), 'décimo oitavo' ) self.assertEqual( num2words(19, lang='pt', ordinal=True), 'décimo nono' ) self.assertEqual( num2words(20, lang='pt', ordinal=True), 'vigésimo' ) self.assertEqual( num2words(21, lang='pt', ordinal=True), 'vigésimo primeiro' ) self.assertEqual( num2words(22, lang='pt', ordinal=True), 'vigésimo segundo' ) self.assertEqual( num2words(35, lang='pt', ordinal=True), 'trigésimo quinto' ) self.assertEqual( num2words(99, lang='pt', ordinal=True), 'nonagésimo nono' ) self.assertEqual( num2words(100, lang='pt', ordinal=True), 'centésimo' ) self.assertEqual( num2words(101, lang='pt', ordinal=True), 'centésimo primeiro' ) self.assertEqual( num2words(128, lang='pt', ordinal=True), 'centésimo vigésimo oitavo' ) self.assertEqual( num2words(713, lang='pt', ordinal=True), 'septigentésimo décimo terceiro' ) self.assertEqual( num2words(1000, lang='pt', ordinal=True), 'milésimo' ) self.assertEqual( num2words(1001, lang='pt', ordinal=True), 'milésimo primeiro' ) self.assertEqual( num2words(1111, lang='pt', ordinal=True), 'milésimo centésimo décimo primeiro' ) self.assertEqual( num2words(2114, lang='pt', ordinal=True), 'segundo milésimo centésimo décimo quarto' ) self.assertEqual( num2words(73421, lang='pt', ordinal=True), 'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro' ) self.assertEqual( num2words(100000, lang='pt', ordinal=True), 'centésimo milésimo' ) self.assertEqual( num2words(250050, lang='pt', ordinal=True), 'ducentésimo quinquagésimo milésimo quinquagésimo' ) self.assertEqual( num2words(6000000, lang='pt', ordinal=True), 'sexto milionésimo' ) self.assertEqual( num2words(19000000000, lang='pt', ordinal=True), 'décimo nono milésimo milionésimo' ) self.assertEqual( num2words(145000000002, lang='pt', ordinal=True), 'centésimo quadragésimo quinto milésimo milionésimo segundo' ) def test_currency_integer(self): self.assertEqual(self.n2w.to_currency(1.00), 'um euro') self.assertEqual(self.n2w.to_currency(2.00), 'dois euros') self.assertEqual(self.n2w.to_currency(3.00), 'três euros') self.assertEqual(self.n2w.to_currency(4.00), 'quatro euros') self.assertEqual(self.n2w.to_currency(5.00), 'cinco euros') self.assertEqual(self.n2w.to_currency(6.00), 'seis euros') self.assertEqual(self.n2w.to_currency(7.00), 'sete euros') self.assertEqual(self.n2w.to_currency(8.00), 'oito euros') self.assertEqual(self.n2w.to_currency(9.00), 'nove euros') self.assertEqual(self.n2w.to_currency(10.00), 'dez euros') self.assertEqual(self.n2w.to_currency(11.00), 'onze euros') self.assertEqual(self.n2w.to_currency(12.00), 'doze euros') self.assertEqual(self.n2w.to_currency(13.00), 'treze euros') self.assertEqual(self.n2w.to_currency(14.00), 'catorze euros') self.assertEqual(self.n2w.to_currency(15.00), 'quinze euros') self.assertEqual(self.n2w.to_currency(16.00), 'dezasseis euros') self.assertEqual(self.n2w.to_currency(17.00), 'dezassete euros') self.assertEqual(self.n2w.to_currency(18.00), 'dezoito euros') self.assertEqual(self.n2w.to_currency(19.00), 'dezanove euros') self.assertEqual(self.n2w.to_currency(20.00), 'vinte euros') self.assertEqual(self.n2w.to_currency(21.00), 'vinte e um euros') self.assertEqual(self.n2w.to_currency(22.00), 'vinte e dois euros') self.assertEqual(self.n2w.to_currency(35.00), 'trinta e cinco euros') self.assertEqual(self.n2w.to_currency(99.00), 'noventa e nove euros') self.assertEqual(self.n2w.to_currency(100.00), 'cem euros') self.assertEqual(self.n2w.to_currency(101.00), 'cento e um euros') self.assertEqual( self.n2w.to_currency(128.00), 'cento e vinte e oito euros' ) self.assertEqual( self.n2w.to_currency(713.00), 'setecentos e treze euros') self.assertEqual(self.n2w.to_currency(1000.00), 'mil euros') self.assertEqual(self.n2w.to_currency(1001.00), 'mil e um euros') self.assertEqual( self.n2w.to_currency(1111.00), 'mil cento e onze euros') self.assertEqual( self.n2w.to_currency(2114.00), 'dois mil cento e catorze euros' ) self.assertEqual( self.n2w.to_currency(73421.00), 'setenta e três mil quatrocentos e vinte e um euros' ) self.assertEqual(self.n2w.to_currency(100000.00), 'cem mil euros') self.assertEqual( self.n2w.to_currency(250050.00), 'duzentos e cinquenta mil e cinquenta euros' ) self.assertEqual( self.n2w.to_currency(6000000.00), 'seis milhões de euros' ) self.assertEqual( self.n2w.to_currency(19000000000.00), 'dezanove mil milhões de euros' ) self.assertEqual( self.n2w.to_currency(145000000002.00), 'cento e quarenta e cinco mil milhões e dois euros' ) self.assertEqual(self.n2w.to_currency(1.00, currency='USD'), 'um dólar') self.assertEqual(self.n2w.to_currency(1.50, currency='USD'), 'um dólar e cinquenta cêntimos') with self.assertRaises(NotImplementedError): self.n2w.to_currency(1.00, currency='CHF') def test_currency_integer_negative(self): self.assertEqual(self.n2w.to_currency(-1.00), 'menos um euro') self.assertEqual( self.n2w.to_currency(-256.00), 'menos duzentos e cinquenta e seis euros' ) self.assertEqual(self.n2w.to_currency(-1000.00), 'menos mil euros') self.assertEqual( self.n2w.to_currency(-1000000.00), 'menos um milhão de euros' ) self.assertEqual( self.n2w.to_currency(-1234567.00), 'menos um milhão duzentos e trinta e quatro mil quinhentos e ' 'sessenta e sete euros' ) def test_currency_float(self): self.assertEqual(self.n2w.to_currency(Decimal('1.00')), 'um euro') self.assertEqual( self.n2w.to_currency(Decimal('1.01')), 'um euro e um cêntimo' ) self.assertEqual( self.n2w.to_currency(Decimal('1.03')), 'um euro e três cêntimos' ) self.assertEqual( self.n2w.to_currency(Decimal('1.35')), 'um euro e trinta e cinco cêntimos' ) self.assertEqual( self.n2w.to_currency(Decimal('3.14')), 'três euros e catorze cêntimos' ) self.assertEqual( self.n2w.to_currency(Decimal('101.22')), 'cento e um euros e vinte e dois cêntimos' ) self.assertEqual( self.n2w.to_currency(Decimal('2345.75')), 'dois mil trezentos e quarenta e cinco euros e setenta e cinco ' 'cêntimos' ) def test_currency_float_negative(self): self.assertEqual( self.n2w.to_currency(Decimal('-2.34')), 'menos dois euros e trinta e quatro cêntimos' ) self.assertEqual( self.n2w.to_currency(Decimal('-9.99')), 'menos nove euros e noventa e nove cêntimos' ) self.assertEqual( self.n2w.to_currency(Decimal('-7.01')), 'menos sete euros e um cêntimo' ) self.assertEqual( self.n2w.to_currency(Decimal('-222.22')), 'menos duzentos e vinte e dois euros e vinte e dois cêntimos' ) def test_year(self): self.assertEqual(self.n2w.to_year(1001), 'mil e um') self.assertEqual( self.n2w.to_year(1789), 'mil setecentos e oitenta e nove' ) self.assertEqual( self.n2w.to_year(1942), 'mil novecentos e quarenta e dois' ) self.assertEqual( self.n2w.to_year(1984), 'mil novecentos e oitenta e quatro' ) self.assertEqual(self.n2w.to_year(2000), 'dois mil') self.assertEqual(self.n2w.to_year(2001), 'dois mil e um') self.assertEqual(self.n2w.to_year(2016), 'dois mil e dezasseis') def test_year_negative(self): self.assertEqual(self.n2w.to_year(-30), 'trinta antes de Cristo') self.assertEqual( self.n2w.to_year(-744), 'setecentos e quarenta e quatro antes de Cristo' ) self.assertEqual(self.n2w.to_year(-10000), 'dez mil antes de Cristo') def test_to_ordinal_num(self): self.assertEqual(self.n2w.to_ordinal_num(1), '1º') self.assertEqual(self.n2w.to_ordinal_num(100), '100º') num2words-0.5.14/tests/test_pt_BR.py000066400000000000000000000404641473005321200173270ustar00rootroot00000000000000# -*- 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 decimal import Decimal from unittest import TestCase from num2words import num2words from num2words.lang_PT_BR import Num2Word_PT_BR class Num2WordsPTBRTest(TestCase): def setUp(self): super(Num2WordsPTBRTest, self).setUp() self.n2w = Num2Word_PT_BR() def test_cardinal_integer(self): self.assertEqual(num2words(1, lang='pt_BR'), 'um') self.assertEqual(num2words(2, lang='pt_BR'), 'dois') self.assertEqual(num2words(3, lang='pt_BR'), 'três') self.assertEqual(num2words(4, lang='pt_BR'), 'quatro') self.assertEqual(num2words(5, lang='pt_BR'), 'cinco') self.assertEqual(num2words(6, lang='pt_BR'), 'seis') self.assertEqual(num2words(7, lang='pt_BR'), 'sete') self.assertEqual(num2words(8, lang='pt_BR'), 'oito') self.assertEqual(num2words(9, lang='pt_BR'), 'nove') self.assertEqual(num2words(10, lang='pt_BR'), 'dez') self.assertEqual(num2words(11, lang='pt_BR'), 'onze') self.assertEqual(num2words(12, lang='pt_BR'), 'doze') self.assertEqual(num2words(13, lang='pt_BR'), 'treze') self.assertEqual(num2words(14, lang='pt_BR'), 'catorze') self.assertEqual(num2words(15, lang='pt_BR'), 'quinze') self.assertEqual(num2words(16, lang='pt_BR'), 'dezesseis') self.assertEqual(num2words(17, lang='pt_BR'), 'dezessete') self.assertEqual(num2words(18, lang='pt_BR'), 'dezoito') self.assertEqual(num2words(19, lang='pt_BR'), 'dezenove') self.assertEqual(num2words(20, lang='pt_BR'), 'vinte') self.assertEqual(num2words(21, lang='pt_BR'), 'vinte e um') self.assertEqual(num2words(22, lang='pt_BR'), 'vinte e dois') self.assertEqual(num2words(35, lang='pt_BR'), 'trinta e cinco') self.assertEqual(num2words(99, lang='pt_BR'), 'noventa e nove') self.assertEqual(num2words(100, lang='pt_BR'), 'cem') self.assertEqual(num2words(101, lang='pt_BR'), 'cento e um') self.assertEqual(num2words(128, lang='pt_BR'), 'cento e vinte e oito') self.assertEqual(num2words(713, lang='pt_BR'), 'setecentos e treze') self.assertEqual(num2words(1000, lang='pt_BR'), 'mil') self.assertEqual(num2words(1001, lang='pt_BR'), 'mil e um') self.assertEqual(num2words(1111, lang='pt_BR'), 'mil, cento e onze') self.assertEqual( num2words(2114, lang='pt_BR'), 'dois mil, cento e catorze' ) self.assertEqual( num2words(73421, lang='pt_BR'), 'setenta e três mil, quatrocentos e vinte e um' ) self.assertEqual(num2words(100000, lang='pt_BR'), 'cem mil') self.assertEqual( num2words(250050, lang='pt_BR'), 'duzentos e cinquenta mil e cinquenta' ) self.assertEqual( num2words(6000000, lang='pt_BR'), 'seis milhões' ) self.assertEqual( num2words(100000000, lang='pt_BR'), 'cem milhões' ) self.assertEqual( num2words(100000000000, lang='pt_BR'), 'cem bilhões' ) self.assertEqual( num2words(19000000000, lang='pt_BR'), 'dezenove bilhões' ) self.assertEqual( num2words(145000000002, lang='pt_BR'), 'cento e quarenta e cinco bilhões e dois' ) def test_cardinal_integer_negative(self): self.assertEqual(num2words(-1, lang='pt_BR'), 'menos um') self.assertEqual( num2words(-256, lang='pt_BR'), 'menos duzentos e cinquenta e seis' ) self.assertEqual(num2words(-1000, lang='pt_BR'), 'menos mil') self.assertEqual(num2words(-1000000, lang='pt_BR'), 'menos um milhão') self.assertEqual( num2words(-1234567, lang='pt_BR'), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e ' 'sessenta e sete' ) def test_cardinal_float(self): self.assertEqual(num2words(Decimal('1.00'), lang='pt_BR'), 'um') self.assertEqual(num2words( Decimal('1.01'), lang='pt_BR'), 'um vírgula zero um') self.assertEqual(num2words( Decimal('1.035'), lang='pt_BR'), 'um vírgula zero três cinco' ) self.assertEqual(num2words( Decimal('1.35'), lang='pt_BR'), 'um vírgula três cinco' ) self.assertEqual( num2words(Decimal('3.14159'), lang='pt_BR'), 'três vírgula um quatro um cinco nove' ) self.assertEqual( num2words(Decimal('101.22'), lang='pt_BR'), 'cento e um vírgula dois dois' ) self.assertEqual( num2words(Decimal('2345.75'), lang='pt_BR'), 'dois mil, trezentos e quarenta e cinco vírgula sete cinco') def test_cardinal_float_negative(self): self.assertEqual( num2words(Decimal('-2.34'), lang='pt_BR'), 'menos dois vírgula três quatro' ) self.assertEqual( num2words(Decimal('-9.99'), lang='pt_BR'), 'menos nove vírgula nove nove' ) self.assertEqual( num2words(Decimal('-7.01'), lang='pt_BR'), 'menos sete vírgula zero um' ) self.assertEqual( num2words(Decimal('-222.22'), lang='pt_BR'), 'menos duzentos e vinte e dois vírgula dois dois' ) def test_ordinal(self): self.assertEqual(num2words(1, lang='pt_BR', ordinal=True), 'primeiro') self.assertEqual(num2words(2, lang='pt_BR', ordinal=True), 'segundo') self.assertEqual(num2words(3, lang='pt_BR', ordinal=True), 'terceiro') self.assertEqual(num2words(4, lang='pt_BR', ordinal=True), 'quarto') self.assertEqual(num2words(5, lang='pt_BR', ordinal=True), 'quinto') self.assertEqual(num2words(6, lang='pt_BR', ordinal=True), 'sexto') self.assertEqual(num2words(7, lang='pt_BR', ordinal=True), 'sétimo') self.assertEqual(num2words(8, lang='pt_BR', ordinal=True), 'oitavo') self.assertEqual(num2words(9, lang='pt_BR', ordinal=True), 'nono') self.assertEqual(num2words(10, lang='pt_BR', ordinal=True), 'décimo') self.assertEqual( num2words(11, lang='pt_BR', ordinal=True), 'décimo primeiro' ) self.assertEqual( num2words(12, lang='pt_BR', ordinal=True), 'décimo segundo' ) self.assertEqual( num2words(13, lang='pt_BR', ordinal=True), 'décimo terceiro' ) self.assertEqual( num2words(14, lang='pt_BR', ordinal=True), 'décimo quarto' ) self.assertEqual( num2words(15, lang='pt_BR', ordinal=True), 'décimo quinto' ) self.assertEqual( num2words(16, lang='pt_BR', ordinal=True), 'décimo sexto' ) self.assertEqual( num2words(17, lang='pt_BR', ordinal=True), 'décimo sétimo' ) self.assertEqual( num2words(18, lang='pt_BR', ordinal=True), 'décimo oitavo' ) self.assertEqual( num2words(19, lang='pt_BR', ordinal=True), 'décimo nono' ) self.assertEqual( num2words(20, lang='pt_BR', ordinal=True), 'vigésimo' ) self.assertEqual( num2words(21, lang='pt_BR', ordinal=True), 'vigésimo primeiro' ) self.assertEqual( num2words(22, lang='pt_BR', ordinal=True), 'vigésimo segundo' ) self.assertEqual( num2words(35, lang='pt_BR', ordinal=True), 'trigésimo quinto' ) self.assertEqual( num2words(99, lang='pt_BR', ordinal=True), 'nonagésimo nono' ) self.assertEqual( num2words(100, lang='pt_BR', ordinal=True), 'centésimo' ) self.assertEqual( num2words(101, lang='pt_BR', ordinal=True), 'centésimo primeiro' ) self.assertEqual( num2words(128, lang='pt_BR', ordinal=True), 'centésimo vigésimo oitavo' ) self.assertEqual( num2words(713, lang='pt_BR', ordinal=True), 'septigentésimo décimo terceiro' ) self.assertEqual( num2words(1000, lang='pt_BR', ordinal=True), 'milésimo' ) self.assertEqual( num2words(1001, lang='pt_BR', ordinal=True), 'milésimo primeiro' ) self.assertEqual( num2words(1111, lang='pt_BR', ordinal=True), 'milésimo centésimo décimo primeiro' ) self.assertEqual( num2words(2114, lang='pt_BR', ordinal=True), 'segundo milésimo centésimo décimo quarto' ) self.assertEqual( num2words(73421, lang='pt_BR', ordinal=True), 'septuagésimo terceiro milésimo quadrigentésimo vigésimo primeiro' ) self.assertEqual( num2words(100000, lang='pt_BR', ordinal=True), 'centésimo milésimo' ) self.assertEqual( num2words(250050, lang='pt_BR', ordinal=True), 'ducentésimo quinquagésimo milésimo quinquagésimo' ) self.assertEqual( num2words(6000000, lang='pt_BR', ordinal=True), 'sexto milionésimo' ) self.assertEqual( num2words(19000000000, lang='pt_BR', ordinal=True), 'décimo nono bilionésimo' ) self.assertEqual( num2words(145000000002, lang='pt_BR', ordinal=True), 'centésimo quadragésimo quinto bilionésimo segundo' ) def test_currency_integer(self): self.assertEqual(self.n2w.to_currency(1), 'um real') self.assertEqual(self.n2w.to_currency(2), 'dois reais') self.assertEqual(self.n2w.to_currency(3), 'três reais') self.assertEqual(self.n2w.to_currency(4), 'quatro reais') self.assertEqual(self.n2w.to_currency(5), 'cinco reais') self.assertEqual(self.n2w.to_currency(6), 'seis reais') self.assertEqual(self.n2w.to_currency(7), 'sete reais') self.assertEqual(self.n2w.to_currency(8), 'oito reais') self.assertEqual(self.n2w.to_currency(9), 'nove reais') self.assertEqual(self.n2w.to_currency(10), 'dez reais') self.assertEqual(self.n2w.to_currency(11), 'onze reais') self.assertEqual(self.n2w.to_currency(12), 'doze reais') self.assertEqual(self.n2w.to_currency(13), 'treze reais') self.assertEqual(self.n2w.to_currency(14), 'catorze reais') self.assertEqual(self.n2w.to_currency(15), 'quinze reais') self.assertEqual(self.n2w.to_currency(16), 'dezesseis reais') self.assertEqual(self.n2w.to_currency(17), 'dezessete reais') self.assertEqual(self.n2w.to_currency(18), 'dezoito reais') self.assertEqual(self.n2w.to_currency(19), 'dezenove reais') self.assertEqual(self.n2w.to_currency(20), 'vinte reais') self.assertEqual(self.n2w.to_currency(21), 'vinte e um reais') self.assertEqual(self.n2w.to_currency(22), 'vinte e dois reais') self.assertEqual(self.n2w.to_currency(35), 'trinta e cinco reais') self.assertEqual(self.n2w.to_currency(99), 'noventa e nove reais') self.assertEqual(self.n2w.to_currency(100), 'cem reais') self.assertEqual(self.n2w.to_currency(101), 'cento e um reais') self.assertEqual( self.n2w.to_currency(128), 'cento e vinte e oito reais' ) self.assertEqual(self.n2w.to_currency(713), 'setecentos e treze reais') self.assertEqual(self.n2w.to_currency(1000), 'mil reais') self.assertEqual(self.n2w.to_currency(1001), 'mil e um reais') self.assertEqual(self.n2w.to_currency(1111), 'mil, cento e onze reais') self.assertEqual( self.n2w.to_currency(2114), 'dois mil, cento e catorze reais' ) self.assertEqual( self.n2w.to_currency(73421), 'setenta e três mil, quatrocentos e vinte e um reais' ) self.assertEqual(self.n2w.to_currency(100000), 'cem mil reais') self.assertEqual( self.n2w.to_currency(250050), 'duzentos e cinquenta mil e cinquenta reais' ) self.assertEqual( self.n2w.to_currency(6000000), 'seis milhões de reais' ) self.assertEqual( self.n2w.to_currency(19000000000), 'dezenove bilhões de reais' ) self.assertEqual( self.n2w.to_currency(145000000002), 'cento e quarenta e cinco bilhões e dois reais' ) def test_currency_integer_negative(self): self.assertEqual(self.n2w.to_currency(-1), 'menos um real') self.assertEqual( self.n2w.to_currency(-256), 'menos duzentos e cinquenta e seis reais' ) self.assertEqual(self.n2w.to_currency(-1000), 'menos mil reais') self.assertEqual( self.n2w.to_currency(-1000000), 'menos um milhão de reais' ) self.assertEqual( self.n2w.to_currency(-1234567), 'menos um milhão, duzentos e trinta e quatro mil, quinhentos e ' 'sessenta e sete reais' ) def test_currency_float(self): self.assertEqual(self.n2w.to_currency(Decimal('1.00')), 'um real') self.assertEqual( self.n2w.to_currency(Decimal('1.01')), 'um real e um centavo' ) self.assertEqual( self.n2w.to_currency(Decimal('1.03')), 'um real e três centavos' ) self.assertEqual( self.n2w.to_currency(Decimal('1.35')), 'um real e trinta e cinco centavos' ) self.assertEqual( self.n2w.to_currency(Decimal('3.14')), 'três reais e catorze centavos' ) self.assertEqual( self.n2w.to_currency(Decimal('101.22')), 'cento e um reais e vinte e dois centavos' ) self.assertEqual( self.n2w.to_currency(Decimal('2345.75')), 'dois mil, trezentos e quarenta e cinco reais e setenta e cinco ' 'centavos' ) def test_currency_float_negative(self): self.assertEqual( self.n2w.to_currency(Decimal('-2.34')), 'menos dois reais e trinta e quatro centavos' ) self.assertEqual( self.n2w.to_currency(Decimal('-9.99')), 'menos nove reais e noventa e nove centavos' ) self.assertEqual( self.n2w.to_currency(Decimal('-7.01')), 'menos sete reais e um centavo' ) self.assertEqual( self.n2w.to_currency(Decimal('-222.22')), 'menos duzentos e vinte e dois reais e vinte e dois centavos' ) def test_year(self): self.assertEqual(self.n2w.to_year(1001), 'mil e um') self.assertEqual( self.n2w.to_year(1789), 'mil, setecentos e oitenta e nove' ) self.assertEqual( self.n2w.to_year(1942), 'mil, novecentos e quarenta e dois' ) self.assertEqual( self.n2w.to_year(1984), 'mil, novecentos e oitenta e quatro' ) self.assertEqual(self.n2w.to_year(2000), 'dois mil') self.assertEqual(self.n2w.to_year(2001), 'dois mil e um') self.assertEqual(self.n2w.to_year(2016), 'dois mil e dezesseis') def test_year_negative(self): self.assertEqual(self.n2w.to_year(-30), 'trinta antes de Cristo') self.assertEqual( self.n2w.to_year(-744), 'setecentos e quarenta e quatro antes de Cristo' ) self.assertEqual(self.n2w.to_year(-10000), 'dez mil antes de Cristo') num2words-0.5.14/tests/test_ro.py000066400000000000000000000165541473005321200167440ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsROTest(TestCase): def test_ordinal(self): self.assertEqual( num2words(1, lang='ro', to='ordinal'), 'primul' ) self.assertEqual( num2words(22, lang='ro', to='ordinal'), u'al douăzeci și doilea' ) self.assertEqual( num2words(21, lang='ro', to='ordinal'), u'al douăzeci și unulea' ) self.assertEqual( num2words(12, lang='ro', to='ordinal'), u'al doisprezecelea' ) self.assertEqual( num2words(130, lang='ro', to='ordinal'), u'al o sută treizecilea' ) self.assertEqual( num2words(1003, lang='ro', to='ordinal'), u'al o mie treilea' ) def test_ordinal_num(self): self.assertEqual( num2words(1, lang='ro', to='ordinal_num'), '1-ul' ) self.assertEqual( num2words(10, lang='ro', to='ordinal_num'), 'al 10-lea' ) self.assertEqual(num2words( 21, lang='ro', to='ordinal_num'), 'al 21-lea' ) self.assertEqual( num2words(102, lang='ro', to='ordinal_num'), 'al 102-lea' ) self.assertEqual( num2words(73, lang='ro', to='ordinal_num'), 'al 73-lea' ) def test_cardinal_for_float_number(self): self.assertEqual( num2words(12.5, lang='ro'), u'doisprezece virgulă cinci' ) self.assertEqual( num2words(12.51, lang='ro'), u'doisprezece virgulă cinci unu' ) self.assertEqual( num2words(12.53, lang='ro'), u'doisprezece virgulă cinci trei' ) self.assertEqual( num2words(12.59, lang='ro'), u'doisprezece virgulă cinci nouă' ) def test_big_numbers(self): self.assertEqual( num2words(1000000, lang="ro"), u"un milion" ) self.assertEqual( num2words(1000000000, lang="ro"), u"un miliard" ) self.assertEqual( num2words(33000000, lang="ro"), u"treizeci și trei milioane" ) self.assertEqual( num2words(247000000000, lang="ro"), u"două sute patruzeci și șapte de miliarde" ) def test_overflow(self): with self.assertRaises(OverflowError): num2words("100000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000") def test_to_currency(self): self.assertEqual( num2words(1000, lang='ro', to='currency'), u'una mie de lei' ) self.assertEqual( num2words(101, lang='ro', to='currency'), u'una sută unu lei' ) self.assertEqual( num2words(100, lang='ro', to='currency'), u'una sută de lei' ) self.assertEqual( num2words(38.4, lang='ro', to='currency'), u'treizeci și opt de lei și patruzeci de bani' ) self.assertEqual( num2words(1.01, lang='ro', to='currency'), u'un leu și un ban' ) self.assertEqual( num2words(4778.00, lang='ro', to='currency'), u'patru mii șapte sute șaptezeci și opt de lei') self.assertEqual( num2words(4778.32, lang='ro', to='currency'), u'patru mii șapte sute șaptezeci și opt de lei' u' și treizeci și doi de bani') self.assertEqual( num2words(1207, lang='ro', to='currency'), u'una mie două sute șapte lei') self.assertEqual( num2words(22000, lang='ro', to='currency'), u'douăzeci și două de mii de lei') self.assertEqual( num2words(80000, lang='ro', to='currency'), u'optzeci de mii de lei') self.assertEqual( num2words(123456789, lang='ro', to='currency'), u'una sută douăzeci și trei milioane patru sute ' u'cincizeci și șase de mii șapte sute optzeci și nouă de lei') def test_to_year(self): self.assertEqual(num2words(1989, lang='ro', to='year'), u'o mie nouă sute optzeci și nouă') self.assertEqual(num2words(1984, lang='ro', to='year'), u'o mie nouă sute optzeci și patru') self.assertEqual(num2words(2018, lang='ro', to='year'), u'două mii optsprezece') self.assertEqual(num2words(1066, lang='ro', to='year'), u'o mie șaizeci și șase') self.assertEqual(num2words(5000, lang='ro', to='year'), u'cinci mii') self.assertEqual(num2words(2001, lang='ro', to='year'), u'două mii unu') self.assertEqual(num2words(905, lang='ro', to='year'), u'nouă sute cinci') self.assertEqual(num2words(6600, lang='ro', to='year'), u'șase mii șase sute') self.assertEqual(num2words(1600, lang='ro', to='year'), u'o mie șase sute') self.assertEqual(num2words(700, lang='ro', to='year'), u'șapte sute') self.assertEqual(num2words(50, lang='ro', to='year'), u'cincizeci') self.assertEqual(num2words(0, lang='ro', to='year'), u'zero') self.assertEqual(num2words(10, lang='ro', to='year'), u'zece') # suffixes self.assertEqual(num2words(-44, lang='ro', to='year'), u'patruzeci și patru î.Hr.') self.assertEqual(num2words(-44, lang='ro', to='year', suffix=u'î.e.n.'), u'patruzeci și patru î.e.n.') self.assertEqual(num2words(1, lang='ro', to='year', suffix='d.Hr.'), u'unu d.Hr.') self.assertEqual(num2words(-66000000, lang='ro', to='year'), u'șaizeci și șase milioane î.Hr.') num2words-0.5.14/tests/test_ru.py000066400000000000000000000550601473005321200167450ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsRUTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(100, lang='ru'), "сто") self.assertEqual(num2words(101, lang='ru'), "сто один") self.assertEqual(num2words(110, lang='ru'), "сто десять") self.assertEqual(num2words(115, lang='ru'), "сто пятнадцать") self.assertEqual(num2words(123, lang='ru'), "сто двадцать три") self.assertEqual(num2words(1000, lang='ru'), "одна тысяча") self.assertEqual(num2words(1001, lang='ru'), "одна тысяча один") self.assertEqual(num2words(2012, lang='ru'), "две тысячи двенадцать") self.assertEqual( num2words(12519.85, lang='ru'), "двенадцать тысяч пятьсот девятнадцать целых восемьдесят пять " "сотых" ) self.assertEqual( num2words(1234567890, lang='ru'), "один миллиард двести тридцать четыре миллиона пятьсот " "шестьдесят семь тысяч восемьсот девяносто") self.assertEqual( num2words(215461407892039002157189883901676, lang='ru'), "двести пятнадцать нониллионов четыреста шестьдесят один " "октиллион четыреста семь септиллионов восемьсот девяносто " "два секстиллиона тридцать девять квинтиллионов два квадриллиона " "сто пятьдесят семь триллионов сто восемьдесят девять миллиардов " "восемьсот восемьдесят три миллиона девятьсот одна тысяча " "шестьсот семьдесят шесть") self.assertEqual( num2words(719094234693663034822824384220291, lang='ru'), "семьсот девятнадцать нониллионов девяносто четыре октиллиона " "двести тридцать четыре септиллиона шестьсот девяносто три " "секстиллиона шестьсот шестьдесят три квинтиллиона тридцать " "четыре квадриллиона восемьсот двадцать два триллиона восемьсот " "двадцать четыре миллиарда триста восемьдесят четыре миллиона " "двести двадцать тысяч двести девяносто один") self.assertEqual(num2words(5, lang='ru'), "пять") self.assertEqual(num2words(15, lang='ru'), "пятнадцать") self.assertEqual(num2words(154, lang='ru'), "сто пятьдесят четыре") self.assertEqual( num2words(1135, lang='ru'), "одна тысяча сто тридцать пять" ) self.assertEqual( num2words(418531, lang='ru'), "четыреста восемнадцать тысяч пятьсот тридцать один" ) self.assertEqual( num2words(1000139, lang='ru'), "один миллион сто тридцать девять" ) self.assertEqual(num2words(-1, lang='ru'), "минус один") self.assertEqual(num2words(-15, lang='ru'), "минус пятнадцать") self.assertEqual(num2words(-100, lang='ru'), "минус сто") def test_cardinal_feminine(self): self.assertEqual(num2words(1, lang='ru', gender='f'), 'одна') self.assertEqual(num2words(2, lang='ru', gender='f'), 'две') self.assertEqual(num2words(3, lang='ru', gender='f'), 'три') self.assertEqual(num2words(100, lang='ru', gender='f'), "сто") self.assertEqual(num2words(101, lang='ru', gender='f'), "сто одна") self.assertEqual(num2words(110, lang='ru', gender='f'), "сто десять") self.assertEqual( num2words(115, lang='ru', gender='f'), "сто пятнадцать" ) self.assertEqual( num2words(122, lang='ru', gender='f'), "сто двадцать две" ) self.assertEqual( num2words(125.1, lang='ru', gender='f'), 'сто двадцать пять целых одна десятая' ) self.assertEqual(num2words(-1, lang='ru', gender='f'), "минус одна") self.assertEqual(num2words(-100, lang='ru', gender='f'), "минус сто") def test_cardinal_neuter(self): self.assertEqual(num2words(1, lang='ru', gender='n'), 'одно') self.assertEqual(num2words(2, lang='ru', gender='n'), 'два') self.assertEqual(num2words(3, lang='ru', gender='n'), 'три') self.assertEqual(num2words(100, lang='ru', gender='n'), "сто") self.assertEqual(num2words(101, lang='ru', gender='n'), "сто одно") self.assertEqual(num2words(110, lang='ru', gender='n'), "сто десять") self.assertEqual( num2words(115, lang='ru', gender='n'), "сто пятнадцать" ) self.assertEqual( num2words(122, lang='ru', gender='n'), "сто двадцать два" ) self.assertEqual( num2words(125.1, lang='ru', gender='n'), 'сто двадцать пять целых одна десятая') self.assertEqual(num2words(-1, lang='ru', gender='n'), "минус одно") self.assertEqual(num2words(-100, lang='ru', gender='n'), "минус сто") def test_floating_point(self): self.assertEqual(num2words(5.2, lang='ru'), "пять целых две десятых") self.assertEqual(num2words(5.0, lang='ru'), "пять целых ноль десятых") self.assertEqual(num2words(5.10, lang='ru'), "пять целых одна десятая") self.assertEqual(num2words("5.10", lang='ru'), "пять целых десять сотых") self.assertEqual(num2words(1.001, lang='ru'), "одна целая одна тысячная") self.assertEqual(num2words(1.011, lang='ru'), "одна целая одиннадцать тысячных") self.assertEqual(num2words(10.02, lang='ru'), "десять целых две сотых") self.assertEqual(num2words(15.007, lang='ru'), "пятнадцать целых семь тысячных") self.assertEqual(num2words(561.42, lang='ru'), "пятьсот шестьдесят одна целая сорок две сотых") self.assertEqual(num2words(561.00001, lang='ru'), "пятьсот шестьдесят одна целая одна стотысячная") def test_to_ordinal(self): self.assertEqual( num2words(0, lang='ru', to='ordinal'), 'нулевой' ) self.assertEqual( num2words(1, lang='ru', to='ordinal'), 'первый' ) self.assertEqual( num2words(5, lang='ru', to='ordinal'), 'пятый' ) self.assertEqual( num2words(10, lang='ru', to='ordinal'), 'десятый' ) self.assertEqual( num2words(13, lang='ru', to='ordinal'), 'тринадцатый' ) self.assertEqual( num2words(20, lang='ru', to='ordinal'), 'двадцатый' ) self.assertEqual( num2words(23, lang='ru', to='ordinal'), 'двадцать третий' ) self.assertEqual( num2words(40, lang='ru', to='ordinal'), 'сороковой' ) self.assertEqual( num2words(70, lang='ru', to='ordinal'), 'семидесятый' ) self.assertEqual( num2words(100, lang='ru', to='ordinal'), 'сотый' ) self.assertEqual( num2words(136, lang='ru', to='ordinal'), 'сто тридцать шестой' ) self.assertEqual( num2words(500, lang='ru', to='ordinal'), 'пятисотый' ) self.assertEqual( num2words(1000, lang='ru', to='ordinal'), 'тысячный' ) self.assertEqual( num2words(1001, lang='ru', to='ordinal'), 'тысяча первый' ) self.assertEqual( num2words(1060, lang='ru', to='ordinal'), 'тысяча шестидесятый' ) self.assertEqual( num2words(2000, lang='ru', to='ordinal'), 'двухтысячный' ) self.assertEqual( num2words(10000, lang='ru', to='ordinal'), 'десятитысячный' ) self.assertEqual( num2words(90000, lang='ru', to='ordinal'), 'девяностотысячный' ) self.assertEqual( num2words(21000, lang='ru', to='ordinal'), 'двадцатиоднотысячный' ) self.assertEqual( num2words(130000, lang='ru', to='ordinal'), 'стотридцатитысячный' ) self.assertEqual( num2words(135000, lang='ru', to='ordinal'), 'стотридцатипятитысячный' ) self.assertEqual( num2words(135100, lang='ru', to='ordinal'), 'сто тридцать пять тысяч сотый' ) self.assertEqual( num2words(135120, lang='ru', to='ordinal'), 'сто тридцать пять тысяч сто двадцатый' ) self.assertEqual( num2words(135121, lang='ru', to='ordinal'), 'сто тридцать пять тысяч сто двадцать первый' ) self.assertEqual( num2words(190000, lang='ru', to='ordinal'), 'стодевяностотысячный' ) self.assertEqual( num2words(1000000, lang='ru', to='ordinal'), 'миллионный' ) self.assertEqual( num2words(2000000, lang='ru', to='ordinal'), 'двухмиллионный' ) self.assertEqual( num2words(5135000, lang='ru', to='ordinal'), 'пять миллионов стотридцатипятитысячный' ) self.assertEqual( num2words(21000000, lang='ru', to='ordinal'), 'двадцатиодномиллионный' ) self.assertEqual( num2words(1000000000, lang='ru', to='ordinal'), 'миллиардный' ) self.assertEqual( num2words(123456000000, lang='ru', to='ordinal'), 'сто двадцать три миллиарда четырёхсотпятидесятишестимиллионный' ) def test_to_ordinal_feminine(self): self.assertEqual( num2words(1, lang='ru', to='ordinal', gender='f'), 'первая' ) self.assertEqual( num2words(3, lang='ru', to='ordinal', gender='f'), 'третья' ) self.assertEqual( num2words(10, lang='ru', to='ordinal', gender='f'), 'десятая' ) self.assertEqual( num2words(23, lang='ru', to='ordinal', gender='f'), 'двадцать третья' ) self.assertEqual( num2words(1000, lang='ru', to='ordinal', gender='f'), 'тысячная' ) self.assertEqual( num2words(2000000, lang='ru', to='ordinal', gender='f'), 'двухмиллионная' ) def test_to_ordinal_neuter(self): self.assertEqual( num2words(1, lang='ru', to='ordinal', gender='n'), 'первое' ) self.assertEqual( num2words(3, lang='ru', to='ordinal', gender='n'), 'третье' ) self.assertEqual( num2words(10, lang='ru', to='ordinal', gender='n'), 'десятое' ) self.assertEqual( num2words(23, lang='ru', to='ordinal', gender='n'), 'двадцать третье' ) self.assertEqual( num2words(1000, lang='ru', to='ordinal', gender='n'), 'тысячное' ) self.assertEqual( num2words(2000000, lang='ru', to='ordinal', gender='n'), 'двухмиллионное' ) def test_cardinal_cases(self): self.assertEqual( num2words(1, lang='ru', case='nominative'), 'один') self.assertEqual( num2words(1, lang='ru', case='genitive'), 'одного') self.assertEqual( num2words(1, lang='ru', case='a', plural=True, animate=False), 'одни') self.assertEqual( num2words(2, lang='ru', case='a', gender='f', animate=True), 'двух') self.assertEqual( num2words(2, lang='ru', case='a', gender='f', animate=False), 'две') self.assertEqual( num2words(100, lang='ru', case='g'), 'ста') self.assertEqual( num2words(122, lang='ru', case='d'), 'ста двадцати двум') self.assertEqual( num2words(1000, lang='ru', case='p'), 'одной тысяче') self.assertEqual( num2words(1122, lang='ru', case='p'), 'одной тысяче ста двадцати двух') self.assertEqual( num2words(1211, lang='ru', case='i', gender='f'), 'одной тысячей двумястами одиннадцатью') self.assertEqual( num2words(5121000, lang='ru', case='i'), 'пятью миллионами ста двадцатью одной тысячей') def test_ordinal_cases(self): self.assertEqual( num2words(1, lang='ru', to='ordinal', case='nominative'), 'первый') self.assertEqual( num2words(1, lang='ru', to='ordinal', case='genitive'), 'первого') self.assertEqual( num2words(1, lang='ru', to='ordinal', case='a', plural=True, animate=False), 'первые') self.assertEqual( num2words(2, lang='ru', to='ordinal', case='a', gender='f', animate=True), 'вторую') self.assertEqual( num2words(2, lang='ru', to='ordinal', case='a', gender='f', animate=False), 'вторую') self.assertEqual( num2words(100, lang='ru', to='ordinal', case='g'), 'сотого') self.assertEqual( num2words(122, lang='ru', to='ordinal', case='d'), 'сто двадцать второму') self.assertEqual( num2words(1000, lang='ru', to='ordinal', case='p'), 'тысячном') self.assertEqual( num2words(1122, lang='ru', to='ordinal', case='p'), 'тысяча сто двадцать втором') self.assertEqual( num2words(1211, lang='ru', to='ordinal', case='i', gender='f'), 'тысяча двести одиннадцатой') self.assertEqual( num2words(5121000, lang='ru', to='ordinal', case='i'), 'пять миллионов стодвадцатиоднотысячным') def test_to_currency(self): self.assertEqual( num2words(1.0, lang='ru', to='currency', currency='EUR'), 'один евро, ноль центов' ) self.assertEqual( num2words(1.0, lang='ru', to='currency', currency='RUB'), 'один рубль, ноль копеек' ) self.assertEqual( num2words(1.0, lang='ru', to='currency', currency='UAH'), 'одна гривна, ноль копеек' ) self.assertEqual( num2words(1234.56, lang='ru', to='currency', currency='EUR'), 'одна тысяча двести тридцать четыре евро, пятьдесят шесть центов' ) self.assertEqual( num2words(1234.56, lang='ru', to='currency', currency='RUB'), 'одна тысяча двести тридцать четыре рубля, пятьдесят шесть копеек' ) self.assertEqual( num2words(1234.56, lang='ru', to='currency', currency='UAH'), 'одна тысяча двести тридцать четыре гривны, пятьдесят шесть копеек' ) self.assertEqual( num2words(10111, lang='ru', to='currency', currency='EUR', separator=' и'), 'сто один евро и одиннадцать центов' ) self.assertEqual( num2words(10111, lang='ru', to='currency', currency='RUB', separator=' и'), 'сто один рубль и одиннадцать копеек' ) self.assertEqual( num2words(10111, lang='ru', to='currency', currency='UAH', separator=' и'), 'сто одна гривна и одиннадцать копеек' ) self.assertEqual( num2words(10121, lang='ru', to='currency', currency='EUR', separator=' и'), 'сто один евро и двадцать один цент' ) self.assertEqual( num2words(10121, lang='ru', to='currency', currency='RUB', separator=' и'), 'сто один рубль и двадцать одна копейка' ) self.assertEqual( num2words(10121, lang='ru', to='currency', currency='UAH', separator=' и'), 'сто одна гривна и двадцать одна копейка' ) self.assertEqual( num2words(10122, lang='ru', to='currency', currency='EUR', separator=' и'), 'сто один евро и двадцать два цента' ) self.assertEqual( num2words(10122, lang='ru', to='currency', currency='RUB', separator=' и'), 'сто один рубль и двадцать две копейки' ) self.assertEqual( num2words(10122, lang='ru', to='currency', currency='UAH', separator=' и'), 'сто одна гривна и двадцать две копейки' ) self.assertEqual( num2words(-1251985, lang='ru', to='currency', currency='EUR', cents=False), 'минус двенадцать тысяч пятьсот девятнадцать евро, 85 центов' ) self.assertEqual( num2words(-1251985, lang='ru', to='currency', currency='RUB', cents=False), 'минус двенадцать тысяч пятьсот девятнадцать рублей, 85 копеек' ) self.assertEqual( num2words(-1251985, lang='ru', to='currency', currency='UAH', cents=False), 'минус двенадцать тысяч пятьсот девятнадцать гривен, 85 копеек' ) self.assertEqual( num2words('38.4', lang='ru', to='currency', separator=' и', cents=False, currency='EUR'), "тридцать восемь евро и 40 центов" ) self.assertEqual( num2words('38.4', lang='ru', to='currency', separator=' и', cents=False, currency='RUB'), "тридцать восемь рублей и 40 копеек" ) self.assertEqual( num2words('38.4', lang='ru', to='currency', separator=' и', cents=False, currency='UAH'), "тридцать восемь гривен и 40 копеек" ) self.assertEqual( num2words('1230.56', lang='ru', to='currency', currency='USD'), 'одна тысяча двести тридцать долларов, пятьдесят шесть центов' ) self.assertEqual( num2words('1231.56', lang='ru', to='currency', currency='USD'), 'одна тысяча двести тридцать один доллар, пятьдесят шесть центов' ) self.assertEqual( num2words('1234.56', lang='ru', to='currency', currency='USD'), 'одна тысяча двести тридцать четыре доллара, пятьдесят шесть ' 'центов' ) self.assertEqual( num2words(10122, lang='ru', to='currency', currency='UZS', separator=' и'), 'сто один сум и двадцать два тийина' ) num2words-0.5.14/tests/test_sk.py000066400000000000000000000103661473005321200167340ustar00rootroot00000000000000 # -*- 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 unittest import TestCase from num2words import num2words class Num2WordsSKTest(TestCase): def test_cardinal(self): self.assertEqual(num2words(100, lang='sk'), "sto") self.assertEqual(num2words(101, lang='sk'), "stojeden") self.assertEqual(num2words(110, lang='sk'), "stodesať") self.assertEqual(num2words(115, lang='sk'), "stopätnásť") self.assertEqual(num2words(123, lang='sk'), "stodvadsaťtri") self.assertEqual(num2words(1000, lang='sk'), "tisíc") self.assertEqual(num2words(1001, lang='sk'), "tisícjeden") self.assertEqual(num2words(2012, lang='sk'), "dvetisícdvanásť") self.assertEqual( num2words(10.02, lang='sk'), "desať celých nula dva" ) self.assertEqual( num2words(15.007, lang='sk'), "pätnásť celých nula nula sedem" ) self.assertEqual( num2words(12519.85, lang='sk'), "dvanásťtisícpäťstodevätnásť celých osemdesiatpäť" ) self.assertEqual( num2words(123.50, lang='sk'), "stodvadsaťtri celých päť" ) self.assertEqual( num2words(1234567890, lang='sk'), "miliarda dvestotridsaťštyri miliónov päťstošesťdesiat" "sedemtisícosemstodeväťdesiat" ) self.assertEqual( num2words(215461407892039002157189883901676, lang='sk'), "dvestopätnásť kvintiliónov štyristošesťdesiatjeden kvadriliárd " "štyristosedem kvadriliónov osemstodeväťdesiatdva triliárd " "tridsaťdeväť triliónov dve biliardy stopäťdesiatsedem biliónov " "stoosemdesiatdeväť miliárd osemstoosemdesiattri miliónov " "deväťstojedentisícšesťstosedemdesiatšesť" ) self.assertEqual( num2words(719094234693663034822824384220291, lang='sk'), "sedemstodevätnásť kvintiliónov deväťdesiatštyri kvadriliárd " "dvestotridsaťštyri kvadriliónov šesťstodeväťdesiattri triliárd " "šesťstošesťdesiattri triliónov tridsaťštyri biliárd " "osemstodvadsaťdva biliónov osemstodvadsaťštyri miliárd " "tristoosemdesiatštyri miliónov " "dvestodvadsaťtisícdvestodeväťdesiatjeden" ) def test_to_ordinal(self): # @TODO: implement to_ordinal with self.assertRaises(NotImplementedError): num2words(1, lang='sk', to='ordinal') def test_currency(self): self.assertEqual( num2words(10.0, lang='sk', to='currency', currency='EUR'), "desať eur, nula centov") self.assertEqual( num2words(1234.56, lang='sk', to='currency', currency='EUR'), "tisícdvestotridsaťštyri eur, päťdesiatšesť centov") self.assertEqual( num2words(101.11, lang='sk', to='currency', currency='EUR', separator=' a'), "stojeden eur a jedenásť centov") self.assertEqual( num2words(-12519.85, lang='sk', to='currency', cents=False), "mínus dvanásťtisícpäťstodevätnásť eur, 85 centov" ) self.assertEqual( num2words(19.50, lang='sk', to='currency', cents=False), "devätnásť eur, 50 centov" ) num2words-0.5.14/tests/test_sl.py000066400000000000000000000270531473005321200167360ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsSLTest(TestCase): def test_ordinal_less_than_twenty(self): self.assertEqual(num2words(2, ordinal=True, lang='sl'), "drugi") self.assertEqual(num2words(4, ordinal=True, lang='sl'), "četrti") self.assertEqual(num2words(7, ordinal=True, lang='sl'), "sedmi") self.assertEqual(num2words(8, ordinal=True, lang='sl'), "osmi") self.assertEqual(num2words(12, ordinal=True, lang='sl'), "dvanajsti") self.assertEqual(num2words(17, ordinal=True, lang='sl'), "sedemnajsti") def test_ordinal_more_than_twenty(self): self.assertEqual( num2words(81, ordinal=True, lang='sl'), "enainosemdeseti" ) def test_ordinal_at_crucial_number(self): self.assertEqual(num2words(100, ordinal=True, lang='sl'), "stoti") self.assertEqual(num2words(1000, ordinal=True, lang='sl'), "tisoči") self.assertEqual( num2words(4000, ordinal=True, lang='sl'), "štiritisoči" ) self.assertEqual( num2words(2000000, ordinal=True, lang='sl'), "dvamilijonti" ) self.assertEqual( num2words(5000000000, ordinal=True, lang='sl'), "petmilijardti" ) def test_ordinal_numbers_from_repository_of_test_cases(self): # Tests were compiled from cases in # https://github.com/gregopet/zapis-slovenskih-stevil # The male gender is used by the project so those test cases were # copied self.assertEqual(num2words(1, ordinal=True, lang='sl'), "prvi") self.assertEqual(num2words(2, ordinal=True, lang='sl'), "drugi") self.assertEqual(num2words(3, ordinal=True, lang='sl'), "tretji") self.assertEqual(num2words(4, ordinal=True, lang='sl'), "četrti") self.assertEqual(num2words(5, ordinal=True, lang='sl'), "peti") self.assertEqual(num2words(6, ordinal=True, lang='sl'), "šesti") self.assertEqual(num2words(7, ordinal=True, lang='sl'), "sedmi") self.assertEqual(num2words(8, ordinal=True, lang='sl'), "osmi") self.assertEqual(num2words(9, ordinal=True, lang='sl'), "deveti") self.assertEqual(num2words(10, ordinal=True, lang='sl'), "deseti") self.assertEqual(num2words(100, ordinal=True, lang='sl'), "stoti") self.assertEqual(num2words(101, ordinal=True, lang='sl'), "stoprvi") self.assertEqual(num2words(102, ordinal=True, lang='sl'), "stodrugi") self.assertEqual(num2words(103, ordinal=True, lang='sl'), "stotretji") self.assertEqual(num2words(104, ordinal=True, lang='sl'), "stočetrti") self.assertEqual(num2words(105, ordinal=True, lang='sl'), "stopeti") self.assertEqual(num2words(106, ordinal=True, lang='sl'), "stošesti") self.assertEqual(num2words(200, ordinal=True, lang='sl'), "dvestoti") self.assertEqual(num2words(1000, ordinal=True, lang='sl'), "tisoči") self.assertEqual(num2words(1001, ordinal=True, lang='sl'), "tisočprvi") self.assertEqual(num2words(1002, ordinal=True, lang='sl'), "tisočdrugi") self.assertEqual(num2words(1003, ordinal=True, lang='sl'), "tisočtretji") self.assertEqual(num2words(1004, ordinal=True, lang='sl'), "tisoččetrti") self.assertEqual(num2words(1005, ordinal=True, lang='sl'), "tisočpeti") self.assertEqual(num2words(1006, ordinal=True, lang='sl'), "tisočšesti") self.assertEqual(num2words(2000, ordinal=True, lang='sl'), "dvatisoči") self.assertEqual(num2words(20000, ordinal=True, lang='sl'), "dvajsettisoči") self.assertEqual(num2words(200000, ordinal=True, lang='sl'), "dvestotisoči") self.assertEqual(num2words(1000000, ordinal=True, lang='sl'), "milijonti") self.assertEqual(num2words(2000000, ordinal=True, lang='sl'), "dvamilijonti") self.assertEqual(num2words(3000000, ordinal=True, lang='sl'), "trimilijonti") self.assertEqual(num2words(101000000, ordinal=True, lang='sl'), "stoenmilijonti") self.assertEqual(num2words(202000000, ordinal=True, lang='sl'), "dvestodvamilijonti") self.assertEqual(num2words(1121, ordinal=True, lang='sl'), "tisočstoenaindvajseti") self.assertEqual(num2words(2405, ordinal=True, lang='sl'), "dvatisočštiristopeti") def test_cardinal_at_some_numbers(self): self.assertEqual(num2words(2, lang='sl'), "dve") self.assertEqual(num2words(4000, lang='sl'), "štiri tisoč") self.assertEqual(num2words(2000000, lang='sl'), "dva milijona") self.assertEqual(num2words(4000000000, lang='sl'), "štiri milijarde") def test_cardinal_numbers_from_repository_of_test_cases(self): # Tests were compiled from cases in # https://github.com/gregopet/zapis-slovenskih-stevil self.assertEqual(num2words(0, lang='sl'), "nič") self.assertEqual(num2words(1, lang='sl'), "ena") self.assertEqual(num2words(2, lang='sl'), "dve") self.assertEqual(num2words(3, lang='sl'), "tri") self.assertEqual(num2words(4, lang='sl'), "štiri") self.assertEqual(num2words(5, lang='sl'), "pet") self.assertEqual(num2words(6, lang='sl'), "šest") self.assertEqual(num2words(7, lang='sl'), "sedem") self.assertEqual(num2words(8, lang='sl'), "osem") self.assertEqual(num2words(9, lang='sl'), "devet") self.assertEqual(num2words(10, lang='sl'), "deset") self.assertEqual(num2words(11, lang='sl'), "enajst") self.assertEqual(num2words(12, lang='sl'), "dvanajst") self.assertEqual(num2words(13, lang='sl'), "trinajst") self.assertEqual(num2words(14, lang='sl'), "štirinajst") self.assertEqual(num2words(15, lang='sl'), "petnajst") self.assertEqual(num2words(16, lang='sl'), "šestnajst") self.assertEqual(num2words(17, lang='sl'), "sedemnajst") self.assertEqual(num2words(18, lang='sl'), "osemnajst") self.assertEqual(num2words(19, lang='sl'), "devetnajst") self.assertEqual(num2words(20, lang='sl'), "dvajset") self.assertEqual(num2words(21, lang='sl'), "enaindvajset") self.assertEqual(num2words(22, lang='sl'), "dvaindvajset") self.assertEqual(num2words(23, lang='sl'), "triindvajset") self.assertEqual(num2words(24, lang='sl'), "štiriindvajset") self.assertEqual(num2words(25, lang='sl'), "petindvajset") self.assertEqual(num2words(26, lang='sl'), "šestindvajset") self.assertEqual(num2words(27, lang='sl'), "sedemindvajset") self.assertEqual(num2words(28, lang='sl'), "osemindvajset") self.assertEqual(num2words(29, lang='sl'), "devetindvajset") self.assertEqual(num2words(30, lang='sl'), "trideset") self.assertEqual(num2words(40, lang='sl'), "štirideset") self.assertEqual(num2words(50, lang='sl'), "petdeset") self.assertEqual(num2words(60, lang='sl'), "šestdeset") self.assertEqual(num2words(70, lang='sl'), "sedemdeset") self.assertEqual(num2words(80, lang='sl'), "osemdeset") self.assertEqual(num2words(90, lang='sl'), "devetdeset") self.assertEqual(num2words(100, lang='sl'), "sto") self.assertEqual(num2words(101, lang='sl'), "sto ena") self.assertEqual(num2words(102, lang='sl'), "sto dve") self.assertEqual(num2words(103, lang='sl'), "sto tri") self.assertEqual(num2words(104, lang='sl'), "sto štiri") self.assertEqual(num2words(105, lang='sl'), "sto pet") self.assertEqual(num2words(106, lang='sl'), "sto šest") self.assertEqual(num2words(200, lang='sl'), "dvesto") self.assertEqual(num2words(300, lang='sl'), "tristo") self.assertEqual(num2words(400, lang='sl'), "štiristo") self.assertEqual(num2words(500, lang='sl'), "petsto") self.assertEqual(num2words(600, lang='sl'), "šeststo") self.assertEqual(num2words(700, lang='sl'), "sedemsto") self.assertEqual(num2words(800, lang='sl'), "osemsto") self.assertEqual(num2words(900, lang='sl'), "devetsto") self.assertEqual(num2words(1000, lang='sl'), "tisoč") self.assertEqual(num2words(1001, lang='sl'), "tisoč ena") self.assertEqual(num2words(1002, lang='sl'), "tisoč dve") self.assertEqual(num2words(1003, lang='sl'), "tisoč tri") self.assertEqual(num2words(1004, lang='sl'), "tisoč štiri") self.assertEqual(num2words(1005, lang='sl'), "tisoč pet") self.assertEqual(num2words(1006, lang='sl'), "tisoč šest") self.assertEqual(num2words(2000, lang='sl'), "dva tisoč") self.assertEqual(num2words(20000, lang='sl'), "dvajset tisoč") self.assertEqual(num2words(100000, lang='sl'), "sto tisoč") self.assertEqual(num2words(101000, lang='sl'), "sto en tisoč") self.assertEqual(num2words(200000, lang='sl'), "dvesto tisoč") self.assertEqual(num2words(1000000, lang='sl'), "milijon") self.assertEqual(num2words(2000000, lang='sl'), "dva milijona") self.assertEqual(num2words(3000000, lang='sl'), "trije milijoni") self.assertEqual(num2words(101000000, lang='sl'), "sto en milijon") self.assertEqual(num2words(202000000, lang='sl'), "dvesto dva milijona") self.assertEqual(num2words(303000000, lang='sl'), "tristo trije milijoni") self.assertEqual(num2words(304000000, lang='sl'), "tristo štirje milijoni") self.assertEqual(num2words(1000000000, lang='sl'), "milijarda") self.assertEqual(num2words(2000000000, lang='sl'), "dve milijardi") self.assertEqual(num2words(1121, lang='sl'), "tisoč sto enaindvajset") self.assertEqual(num2words(2401, lang='sl'), "dva tisoč štiristo ena") self.assertEqual(num2words(201001004, lang='sl'), "dvesto en milijon tisoč štiri") self.assertEqual( num2words(1803603801, lang='sl'), "milijarda osemsto trije milijoni šeststo tri tisoč osemsto ena") def test_cardinal_for_decimal_number(self): self.assertEqual(num2words(3.48, lang='sl'), "tri celih štiri osem") def test_ordinal_for_negative_numbers(self): self.assertRaises(TypeError, num2words, -12, ordinal=True, lang='sl') def test_ordinal_for_floating_numbers(self): self.assertRaises(TypeError, num2words, 2.453, ordinal=True, lang='sl') num2words-0.5.14/tests/test_sr.py000066400000000000000000000210541473005321200167370ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsSRTest(TestCase): def test_cardinal(self): self.assertEqual("sto", num2words(100, lang='sr')) self.assertEqual("sto jedan", num2words(101, lang='sr')) self.assertEqual("sto deset", num2words(110, lang='sr')) self.assertEqual("sto petnaest", num2words(115, lang='sr')) self.assertEqual( "sto dvadeset tri", num2words(123, lang='sr') ) self.assertEqual( "jedna hiljada", num2words(1000, lang='sr') ) self.assertEqual( "jedna hiljada jedan", num2words(1001, lang='sr') ) self.assertEqual( "dve hiljade dvanaest", num2words(2012, lang='sr') ) self.assertEqual( "dvanaest hiljada petsto devetnaest zapeta osamdeset pet", num2words(12519.85, lang='sr') ) self.assertEqual( "jedan bilion dvesta trideset četiri miliona petsto " "šezdeset sedam hiljada osamsto devedeset", num2words(1234567890, lang='sr') ) self.assertEqual( "dvesta petnaest noniliona četristo šezdeset jedan " "oktilion četristo sedam septiliona osamsto devedeset " "dva sekstiliona trideset devet kvintiliona dva kvadriliona " "sto pedeset sedam triliona sto osamdeset devet biliona " "osamsto osamdeset tri miliona devetsto jedna hiljada " "šesto sedamdeset šest", num2words(215461407892039002157189883901676, lang='sr') ) self.assertEqual( "sedamsto devetnaest noniliona devedeset četiri oktiliona " "dvesta trideset četiri septiliona šesto devedeset tri " "sekstiliona šesto šezdeset tri kvintiliona trideset " "četiri kvadriliona osamsto dvadeset dva triliona osamsto " "dvadeset četiri biliona trista osamdeset četiri miliona " "dvesta dvadeset hiljada dvesta devedeset jedan", num2words(719094234693663034822824384220291, lang='sr') ) self.assertEqual("pet", num2words(5, lang='sr')) self.assertEqual("petnaest", num2words(15, lang='sr')) self.assertEqual("sto pedeset četiri", num2words(154, lang='sr')) self.assertEqual( "jedna hiljada sto trideset pet", num2words(1135, lang='sr') ) self.assertEqual( "četristo osamnaest hiljada petsto trideset jedan", num2words(418531, lang='sr'), ) self.assertEqual( "jedan milion sto trideset devet", num2words(1000139, lang='sr') ) def test_floating_point(self): self.assertEqual("pet zapeta dva", num2words(5.2, lang='sr')) self.assertEqual( num2words(10.02, lang='sr'), "deset zapeta nula dva" ) self.assertEqual( num2words(15.007, lang='sr'), "petnaest zapeta nula nula sedam" ) self.assertEqual( "petsto šezdeset jedan zapeta četrdeset dva", num2words(561.42, lang='sr') ) def test_to_ordinal(self): # @TODO: implement to_ordinal with self.assertRaises(NotImplementedError): num2words(1, lang='sr', to='ordinal') def test_to_currency(self): self.assertEqual( 'jedan evro, nula centi', num2words(1.0, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'dva evra, nula centi', num2words(2.0, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'pet evra, nula centi', num2words(5.0, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'dva evra, jedan cent', num2words(2.01, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'dva evra, dva centa', num2words(2.02, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'dva evra, pet centi', num2words(2.05, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'dve rublje, nula kopejki', num2words(2.0, lang='sr', to='currency', currency='RUB') ) self.assertEqual( 'dve rublje, jedna kopejka', num2words(2.01, lang='sr', to='currency', currency='RUB') ) self.assertEqual( 'dve rublje, dve kopejke', num2words(2.02, lang='sr', to='currency', currency='RUB') ) self.assertEqual( 'dve rublje, pet kopejki', num2words(2.05, lang='sr', to='currency', currency='RUB') ) self.assertEqual( 'jedan dinar, nula para', num2words(1.0, lang='sr', to='currency', currency='RSD') ) self.assertEqual( 'dva dinara, dve pare', num2words(2.02, lang='sr', to='currency', currency='RSD') ) self.assertEqual( 'pet dinara, pet para', num2words(5.05, lang='sr', to='currency', currency='RSD') ) self.assertEqual( 'jedanaest dinara, jedanaest para', num2words(11.11, lang='sr', to='currency', currency='RSD') ) self.assertEqual( 'dvadeset jedan dinar, dvadeset jedna para', num2words(21.21, lang='sr', to='currency', currency='RSD') ) self.assertEqual( 'dvadeset jedan evro, dvadeset jedan cent', num2words(21.21, lang='sr', to='currency', currency='EUR') ) self.assertEqual( 'dvadeset jedna rublja, dvadeset jedna kopejka', num2words(21.21, lang='sr', to='currency', currency='RUB') ) self.assertEqual( 'jedna hiljada dvesta trideset četiri evra, ' 'pedeset šest centi', num2words( 1234.56, lang='sr', to='currency', currency='EUR' ) ) self.assertEqual( 'jedna hiljada dvesta trideset četiri rublje, ' 'pedeset šest kopejki', num2words( 1234.56, lang='sr', to='currency', currency='RUB' ) ) self.assertEqual( 'sto jedan evro i jedanaest centi', num2words( 10111, lang='sr', to='currency', currency='EUR', separator=' i' ) ) self.assertEqual( 'sto jedna rublja i dvadeset jedna kopejka', num2words( 10121, lang='sr', to='currency', currency='RUB', separator=' i' ) ) self.assertEqual( 'sto jedna rublja i dvadeset dve kopejke', num2words(10122, lang='sr', to='currency', currency='RUB', separator=' i') ) self.assertEqual( 'sto jedan evro i dvadeset jedan cent', num2words(10121, lang='sr', to='currency', currency='EUR', separator=' i'), ) self.assertEqual( 'minus dvanaest hiljada petsto devetnaest evra, 85 centi', num2words( -1251985, lang='sr', to='currency', currency='EUR', cents=False ) ) self.assertEqual( "trideset osam evra i 40 centi", num2words('38.4', lang='sr', to='currency', separator=' i', cents=False, currency='EUR'), ) num2words-0.5.14/tests/test_sv.py000066400000000000000000000070301473005321200167410ustar00rootroot00000000000000# 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 unittest import TestCase from num2words import num2words class Num2WordsSVTest(TestCase): def test_ordinal(self): self.assertEqual(num2words(14, to="ordinal", lang="sv"), "fjortonde") self.assertEqual(num2words(1435, to="ordinal", lang="sv"), "etttusen fyrahundratrettiofemte") self.assertEqual(num2words(32, to="ordinal", lang="sv"), "trettioandra") self.assertEqual(num2words(1, to="ordinal", lang="sv"), "första") self.assertEqual(num2words(5, to="ordinal", lang="sv"), "femte") self.assertEqual(num2words(10, to="ordinal", lang="sv"), "tionde") def test_cardinal(self): self.assertEqual(num2words(0, to="cardinal", lang="sv"), "noll") self.assertEqual(num2words(1, to="cardinal", lang="sv"), "ett") self.assertEqual(num2words(3, to="cardinal", lang="sv"), "tre") self.assertEqual(num2words(5, to="cardinal", lang="sv"), "fem") self.assertEqual(num2words(18, to="cardinal", lang="sv"), "arton") self.assertEqual(num2words(45, to="cardinal", lang="sv"), "förtiofem") self.assertEqual(num2words(1345, to="cardinal", lang="sv"), "etttusen trehundraförtiofem") self.assertEqual(num2words(4435, to="cardinal", lang="sv"), "fyratusen fyrahundratrettiofem") self.assertEqual(num2words(1004135, to="cardinal", lang="sv"), "en miljon fyratusen etthundratrettiofem") self.assertEqual(num2words(4335000, to="cardinal", lang="sv"), "fyra miljoner trehundratrettiofemtusen") self.assertEqual(num2words(14004535, to="cardinal", lang="sv"), "fjorton miljoner fyratusen femhundratrettiofem") self.assertEqual(num2words(1.5, to="cardinal", lang="sv"), "ett komma fem") def test_not_implemented_options(self): with self.assertRaises(NotImplementedError) as context: num2words(1235, to="year", lang="sv") self.assertTrue("'year' is not implemented for swedish language" in str(context.exception)) with self.assertRaises(NotImplementedError) as context: num2words(1235, to="currency", lang="sv") self.assertTrue("'currency' is not implemented for swedish language" in str(context.exception)) with self.assertRaises(NotImplementedError) as context: num2words(1235, to="ordinal_num", lang="sv") self.assertTrue("'ordinal_num' is not implemented for swedish language" in str(context.exception)) num2words-0.5.14/tests/test_te.py000066400000000000000000000101271473005321200167220ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsTETest(TestCase): def test_numbers(self): self.assertEqual(num2words(66, lang="te"), u"అరవై ఆరు") self.assertEqual(num2words(1734, lang="te"), u"ఒకటి వేయి ఏడు వందల ముప్పై నాలుగు") self.assertEqual(num2words(134, lang="te"), u"ఒకటి వందల ముప్పై నాలుగు") self.assertEqual(num2words(54411, lang="te"), u"యాభై నాలుగు వేయి నాలుగు వందల పదకొండు") self.assertEqual(num2words(42, lang="te"), u"నలభై రెండు") self.assertEqual(num2words(893, lang="te"), u"ఎనిమిది వందల తొంభై మూడు") self.assertEqual( num2words(1729, lang="te"), u"ఒకటి వేయి ఏడు వందల ఇరవై తొమ్మిది" ) self.assertEqual(num2words(123, lang="te"), u"ఒకటి వందల ఇరవై మూడు") self.assertEqual(num2words(32211, lang="te"), u"ముప్పై రెండు వేయి రెండు వందల పదకొండు") def test_cardinal_for_float_number(self): self.assertEqual(num2words(1.61803, lang="te"), u"ఒకటి బిందువు ఆరు ఒకటి ఎనిమిది సున్న మూడు") self.assertEqual(num2words(34.876, lang="te"), u"ముప్పై నాలుగు బిందువు ఎనిమిది ఏడు ఆరు") self.assertEqual(num2words(3.14, lang="te"), u"మూడు బిందువు ఒకటి నాలుగు") def test_ordinal(self): self.assertEqual(num2words(1, lang='te', to='ordinal'), u"ఒకటివ") self.assertEqual(num2words(22, lang='te', to='ordinal'), u"ఇరవై రెండువ") self.assertEqual(num2words(23, lang='te', to='ordinal'), u"ఇరవై మూడువ") self.assertEqual(num2words(12, lang='te', to='ordinal'), u"పన్నెండువ") self.assertEqual(num2words(130, lang='te', to='ordinal'), u"ఒకటి వందల ముప్పైవ") self.assertEqual(num2words(1003, lang='te', to='ordinal'), u"ఒకటి వేయిల మూడువ") self.assertEqual(num2words(4, lang='te', to='ordinal'), u"నాలుగువ") def test_ordinal_num(self): self.assertEqual(num2words(2, lang="te", to='ordinal_num'), u"2వ") self.assertEqual(num2words(3, lang="te", to='ordinal_num'), u"3వ") self.assertEqual(num2words(5, lang="te", to='ordinal_num'), u"5వ") self.assertEqual(num2words(16, lang="te", to='ordinal_num'), u"16వ") self.assertEqual(num2words(113, lang="te", to='ordinal_num'), u"113వ") num2words-0.5.14/tests/test_tet.py000066400000000000000000000502351473005321200171120ustar00rootroot00000000000000# -*- 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 import decimal from decimal import Decimal from unittest import TestCase from num2words import num2words from num2words.lang_TET import Num2Word_TET class Num2WordsTETTest(TestCase): def setUp(self): super().setUp() self.n2w = Num2Word_TET() def test_cardinal_integer(self): self.assertEqual(num2words(1, lang='tet'), 'ida') self.assertEqual(num2words(2, lang='tet'), 'rua') self.assertEqual(num2words(3, lang='tet'), 'tolu') self.assertEqual(num2words(4, lang='tet'), 'haat') self.assertEqual(num2words(5, lang='tet'), 'lima') self.assertEqual(num2words(6, lang='tet'), 'neen') self.assertEqual(num2words(7, lang='tet'), 'hitu') self.assertEqual(num2words(8, lang='tet'), 'ualu') self.assertEqual(num2words(9, lang='tet'), 'sia') self.assertEqual(num2words(10, lang='tet'), 'sanulu') self.assertEqual(num2words(11, lang='tet'), 'sanulu resin ida') self.assertEqual(num2words(12, lang='tet'), 'sanulu resin rua') self.assertEqual(num2words(13, lang='tet'), 'sanulu resin tolu') self.assertEqual(num2words(14, lang='tet'), 'sanulu resin haat') self.assertEqual(num2words(15, lang='tet'), 'sanulu resin lima') self.assertEqual(num2words(16, lang='tet'), 'sanulu resin neen') self.assertEqual(num2words(17, lang='tet'), 'sanulu resin hitu') self.assertEqual(num2words(18, lang='tet'), 'sanulu resin ualu') self.assertEqual(num2words(19, lang='tet'), 'sanulu resin sia') self.assertEqual(num2words(20, lang='tet'), 'ruanulu') self.assertEqual(num2words(21, lang='tet'), 'ruanulu resin ida') self.assertEqual(num2words(22, lang='tet'), 'ruanulu resin rua') self.assertEqual(num2words(35, lang='tet'), 'tolunulu resin lima') self.assertEqual(num2words(99, lang='tet'), 'sianulu resin sia') self.assertEqual(num2words(100, lang='tet'), 'atus ida') self.assertEqual(num2words(101, lang='tet'), 'atus ida ida') self.assertEqual(num2words(107, lang='tet'), 'atus ida hitu') self.assertEqual(num2words(110, lang='tet'), 'atus ida sanulu') self.assertEqual( num2words(114, lang='tet'), 'atus ida sanulu resin haat' ) self.assertEqual( num2words(128, lang='tet'), 'atus ida ruanulu resin ualu' ) self.assertEqual( num2words(151, lang='tet'), 'atus ida limanulu resin ida' ) self.assertEqual( num2words(713, lang='tet'), 'atus hitu sanulu resin tolu' ) self.assertEqual( num2words(999, lang='tet'), 'atus sia sianulu resin sia' ) self.assertEqual(num2words(1000, lang='tet'), 'rihun ida') self.assertEqual(num2words(1001, lang='tet'), 'rihun ida ida') self.assertEqual( num2words(1011, lang='tet'), 'rihun ida sanulu resin ida' ) self.assertEqual( num2words(1111, lang='tet'), 'rihun ida atus ida sanulu resin ida' ) self.assertEqual( num2words(2357, lang='tet'), 'rihun rua atus tolu limanulu resin hitu' ) self.assertEqual( num2words(2200, lang='tet'), 'rihun rua atus rua' ) self.assertEqual( num2words(2230, lang='tet'), 'rihun rua atus rua tolunulu' ) self.assertEqual( num2words(73400, lang='tet'), 'rihun hitunulu resin tolu atus haat' ) self.assertEqual( num2words(73421, lang='tet'), 'rihun hitunulu resin tolu atus haat ruanulu resin ida' ) self.assertEqual(num2words(100000, lang='tet'), 'rihun atus ida') self.assertEqual( num2words(250050, lang='tet'), 'rihun atus rua limanulu limanulu' ) self.assertEqual( num2words(6000000, lang='tet'), 'miliaun neen' ) self.assertEqual( num2words(100000000, lang='tet'), 'miliaun atus ida' ) self.assertEqual( num2words(19000000000, lang='tet'), 'miliaun rihun sanulu resin sia' ) self.assertEqual( num2words(145000000002, lang='tet'), 'miliaun rihun atus ida haatnulu resin lima resin rua' ) self.assertEqual( num2words(4635102, lang='tet'), 'miliaun haat rihun atus neen tolunulu resin lima atus ida rua' ) self.assertEqual( num2words(145254635102, lang='tet'), "miliaun rihun atus ida haatnulu resin lima atus rua limanulu \ resin haat rihun atus neen tolunulu resin lima atus ida rua" ) self.assertEqual( num2words(1000000000000, lang='tet'), 'biliaun ida' ) self.assertEqual( num2words(2000000000000, lang='tet'), 'biliaun rua' ) self.assertEqual( num2words(1000000000000000, lang='tet'), 'biliaun rihun ida' ) self.assertEqual( num2words(2000000000000000, lang='tet'), 'biliaun rihun rua' ) self.assertEqual( num2words(1000000000000000000, lang='tet'), 'triliaun ida' ) self.assertEqual( num2words(2000000000000000000, lang='tet'), 'triliaun rua' ) def test_cardinal_integer_negative(self): self.assertEqual(num2words(-1, lang='tet'), 'menus ida') self.assertEqual( num2words(-256, lang='tet'), 'menus atus rua limanulu resin neen' ) self.assertEqual(num2words(-1000, lang='tet'), 'menus rihun ida') self.assertEqual(num2words(-1000000, lang='tet'), 'menus miliaun ida') self.assertEqual( num2words(-1234567, lang='tet'), 'menus miliaun ida rihun atus rua tolunulu resin \ haat atus lima neenulu resin hitu' ) def test_cardinal_float(self): self.assertEqual(num2words(Decimal('1.00'), lang='tet'), 'ida') self.assertEqual(num2words( Decimal('1.01'), lang='tet'), 'ida vírgula mamuk ida') self.assertEqual(num2words( Decimal('1.035'), lang='tet'), 'ida vírgula mamuk tolu lima' ) self.assertEqual(num2words( Decimal('1.35'), lang='tet'), 'ida vírgula tolu lima' ) self.assertEqual( num2words(Decimal('3.14159'), lang='tet'), 'tolu vírgula ida haat ida lima sia' ) self.assertEqual( num2words(Decimal('101.22'), lang='tet'), 'atus ida ida vírgula rua rua' ) self.assertEqual( num2words(Decimal('2345.75'), lang='tet'), 'rihun rua atus tolu haatnulu resin lima vírgula hitu lima' ) def test_cardinal_float_negative(self): self.assertEqual( num2words(Decimal('-2.34'), lang='tet'), 'menus rua vírgula tolu haat' ) self.assertEqual( num2words(Decimal('-9.99'), lang='tet'), 'menus sia vírgula sia sia' ) self.assertEqual( num2words(Decimal('-7.01'), lang='tet'), 'menus hitu vírgula mamuk ida' ) self.assertEqual( num2words(Decimal('-222.22'), lang='tet'), 'menus atus rua ruanulu resin rua vírgula rua rua' ) def test_ordinal(self): with self.assertRaises(decimal.InvalidOperation): num2words("hello", lang='tet', ordinal=True) with self.assertRaises(TypeError): num2words(5.1, lang='tet', ordinal=True) self.assertEqual(num2words(1, lang='tet', ordinal=True), 'dahuluk') self.assertEqual(num2words(2, lang='tet', ordinal=True), 'daruak') self.assertEqual(num2words(3, lang='tet', ordinal=True), 'datoluk') self.assertEqual(num2words(4, lang='tet', ordinal=True), 'dahaat') self.assertEqual(num2words(5, lang='tet', ordinal=True), 'dalimak') self.assertEqual(num2words(6, lang='tet', ordinal=True), 'daneen') self.assertEqual(num2words(7, lang='tet', ordinal=True), 'dahituk') self.assertEqual(num2words(8, lang='tet', ordinal=True), 'daualuk') self.assertEqual(num2words(9, lang='tet', ordinal=True), 'dasiak') self.assertEqual(num2words(10, lang='tet', ordinal=True), 'dasanuluk') self.assertEqual( num2words(11, lang='tet', ordinal=True), 'dasanulu resin idak' ) self.assertEqual( num2words(12, lang='tet', ordinal=True), 'dasanulu resin ruak' ) self.assertEqual( num2words(13, lang='tet', ordinal=True), 'dasanulu resin toluk' ) self.assertEqual( num2words(14, lang='tet', ordinal=True), 'dasanulu resin haat' ) self.assertEqual( num2words(15, lang='tet', ordinal=True), 'dasanulu resin limak' ) self.assertEqual( num2words(16, lang='tet', ordinal=True), 'dasanulu resin neen' ) self.assertEqual( num2words(17, lang='tet', ordinal=True), 'dasanulu resin hituk' ) self.assertEqual( num2words(18, lang='tet', ordinal=True), 'dasanulu resin ualuk' ) self.assertEqual( num2words(19, lang='tet', ordinal=True), 'dasanulu resin siak' ) self.assertEqual( num2words(20, lang='tet', ordinal=True), 'daruanuluk' ) self.assertEqual( num2words(21, lang='tet', ordinal=True), 'daruanulu resin idak' ) self.assertEqual( num2words(22, lang='tet', ordinal=True), 'daruanulu resin ruak' ) self.assertEqual( num2words(35, lang='tet', ordinal=True), 'datolunulu resin limak' ) self.assertEqual( num2words(99, lang='tet', ordinal=True), 'dasianulu resin siak' ) self.assertEqual( num2words(100, lang='tet', ordinal=True), 'dahatus idak' ) self.assertEqual( num2words(101, lang='tet', ordinal=True), 'dahatus ida idak' ) self.assertEqual( num2words(106, lang='tet', ordinal=True), 'dahatus ida neen' ) self.assertEqual( num2words(128, lang='tet', ordinal=True), 'dahatus ida ruanulu resin ualuk' ) self.assertEqual( num2words(600, lang='tet', ordinal=True), 'dahatus neen' ) self.assertEqual( num2words(713, lang='tet', ordinal=True), 'dahatus hitu sanulu resin toluk' ) self.assertEqual( num2words(1000, lang='tet', ordinal=True), 'darihun idak' ) self.assertEqual( num2words(1001, lang='tet', ordinal=True), 'darihun ida idak' ) self.assertEqual( num2words(1111, lang='tet', ordinal=True), 'darihun ida atus ida sanulu resin idak' ) self.assertEqual( num2words(2114, lang='tet', ordinal=True), 'darihun rua atus ida sanulu resin haat' ) self.assertEqual( num2words(73421, lang='tet', ordinal=True), 'darihun hitunulu resin tolu atus haat ruanulu resin idak' ) self.assertEqual( num2words(100000, lang='tet', ordinal=True), 'darihun atus idak' ) self.assertEqual( num2words(250050, lang='tet', ordinal=True), 'darihun atus rua limanulu limanuluk' ) self.assertEqual( num2words(6000000, lang='tet', ordinal=True), 'damiliaun neen' ) self.assertEqual( num2words(19000000000, lang='tet', ordinal=True), 'damiliaun rihun sanulu resin siak' ) self.assertEqual( num2words(145000000002, lang='tet', ordinal=True), 'damiliaun rihun atus ida haatnulu resin lima resin ruak' ) def test_currency_integer(self): self.assertEqual(self.n2w.to_currency(1.00), 'dolar ida') self.assertEqual(self.n2w.to_currency(2.00), 'dolar rua') self.assertEqual(self.n2w.to_currency(3.00), 'dolar tolu') self.assertEqual(self.n2w.to_currency(4.00), 'dolar haat') self.assertEqual(self.n2w.to_currency(5.00), 'dolar lima') self.assertEqual(self.n2w.to_currency(6.00), 'dolar neen') self.assertEqual(self.n2w.to_currency(7.00), 'dolar hitu') self.assertEqual(self.n2w.to_currency(8.00), 'dolar ualu') self.assertEqual(self.n2w.to_currency(9.00), 'dolar sia') self.assertEqual(self.n2w.to_currency(10.00), 'dolar sanulu') self.assertEqual(self.n2w.to_currency(11.00), 'dolar sanulu resin ida') self.assertEqual(self.n2w.to_currency(12.00), 'dolar sanulu resin rua') self.assertEqual( self.n2w.to_currency(13.00), 'dolar sanulu resin tolu' ) self.assertEqual( self.n2w.to_currency(14.00), 'dolar sanulu resin haat' ) self.assertEqual( self.n2w.to_currency(15.00), 'dolar sanulu resin lima' ) self.assertEqual( self.n2w.to_currency(16.00), 'dolar sanulu resin neen' ) self.assertEqual( self.n2w.to_currency(17.00), 'dolar sanulu resin hitu' ) self.assertEqual( self.n2w.to_currency(18.00), 'dolar sanulu resin ualu' ) self.assertEqual( self.n2w.to_currency(19.00), 'dolar sanulu resin sia' ) self.assertEqual(self.n2w.to_currency(20.00), 'dolar ruanulu') self.assertEqual( self.n2w.to_currency(21.00), 'dolar ruanulu resin ida' ) self.assertEqual( self.n2w.to_currency(22.00), 'dolar ruanulu resin rua' ) self.assertEqual( self.n2w.to_currency(35.00), 'dolar tolunulu resin lima' ) self.assertEqual( self.n2w.to_currency(99.00), 'dolar sianulu resin sia' ) self.assertEqual(self.n2w.to_currency(100.00), 'dolar atus ida') self.assertEqual(self.n2w.to_currency(101.00), 'dolar atus ida ida') self.assertEqual( self.n2w.to_currency(128.00), 'dolar atus ida ruanulu resin ualu' ) self.assertEqual( self.n2w.to_currency(713.00), 'dolar atus hitu sanulu resin tolu') self.assertEqual(self.n2w.to_currency(1000.00), 'dolar rihun ida') self.assertEqual(self.n2w.to_currency(1001.00), 'dolar rihun ida ida') self.assertEqual( self.n2w.to_currency(1111.00), 'dolar rihun ida atus ida sanulu resin ida' ) self.assertEqual( self.n2w.to_currency(2114.00), 'dolar rihun rua atus ida sanulu resin haat' ) self.assertEqual( self.n2w.to_currency(73421.00), 'dolar rihun hitunulu resin tolu atus haat ruanulu resin ida' ) self.assertEqual( self.n2w.to_currency(100000.00), 'dolar rihun atus ida' ) self.assertEqual( self.n2w.to_currency(250050.00), 'dolar rihun atus rua limanulu limanulu' ) self.assertEqual( self.n2w.to_currency(6000000.00), 'dolar miliaun neen' ) self.assertEqual( self.n2w.to_currency(19000000000.00), 'dolar miliaun rihun sanulu resin sia' ) self.assertEqual( self.n2w.to_currency(145000000002.00), 'dolar miliaun rihun atus ida haatnulu resin lima resin rua' ) self.assertEqual(self.n2w.to_currency(1.00, currency='USD'), 'dolar ida') self.assertEqual(self.n2w.to_currency(1.50, currency='USD'), 'dolar ida sentavu limanulu') with self.assertRaises(NotImplementedError): self.n2w.to_currency(1.00, currency='CHF') def test_currency_integer_negative(self): self.assertEqual(self.n2w.to_currency(-1.00), 'menus dolar ida') self.assertEqual( self.n2w.to_currency(-256.00), 'menus dolar atus rua limanulu resin neen' ) self.assertEqual( self.n2w.to_currency(-1000.00), 'menus dolar rihun ida' ) self.assertEqual( self.n2w.to_currency(-1000000.00), 'menus dolar miliaun ida' ) self.assertEqual( self.n2w.to_currency(-1234567.00), 'menus dolar miliaun ida rihun atus rua tolunulu \ resin haat atus lima neenulu resin hitu' ) def test_currency_float(self): self.assertEqual(self.n2w.to_currency(Decimal('1.00')), 'dolar ida') self.assertEqual( self.n2w.to_currency(Decimal('1.01')), 'dolar ida sentavu ida' ) self.assertEqual( self.n2w.to_currency(Decimal('1.03')), 'dolar ida sentavu tolu' ) self.assertEqual( self.n2w.to_currency(Decimal('1.35')), 'dolar ida sentavu tolunulu resin lima' ) self.assertEqual( self.n2w.to_currency(Decimal('3.14')), 'dolar tolu sentavu sanulu resin haat' ) self.assertEqual( self.n2w.to_currency(Decimal('101.22')), 'dolar atus ida ida sentavu ruanulu resin rua' ) self.assertEqual( self.n2w.to_currency(Decimal('2345.75')), 'dolar rihun rua atus tolu haatnulu resin \ lima sentavu hitunulu resin lima' ) def test_currency_float_negative(self): self.assertEqual( self.n2w.to_currency(Decimal('-2.34')), 'menus dolar rua sentavu tolunulu resin haat' ) self.assertEqual( self.n2w.to_currency(Decimal('-9.99')), 'menus dolar sia sentavu sianulu resin sia' ) self.assertEqual( self.n2w.to_currency(Decimal('-7.01')), 'menus dolar hitu sentavu ida' ) self.assertEqual( self.n2w.to_currency(Decimal('-222.22')), 'menus dolar atus rua ruanulu resin rua sentavu ruanulu resin rua' ) def test_year(self): self.assertEqual(self.n2w.to_year(1001), 'rihun ida ida') self.assertEqual( self.n2w.to_year(1789), 'rihun ida atus hitu ualunulu resin sia' ) self.assertEqual( self.n2w.to_year(1942), 'rihun ida atus sia haatnulu resin rua' ) self.assertEqual( self.n2w.to_year(1984), 'rihun ida atus sia ualunulu resin haat' ) self.assertEqual(self.n2w.to_year(2000), 'rihun rua') self.assertEqual(self.n2w.to_year(2001), 'rihun rua ida') self.assertEqual(self.n2w.to_year(2016), 'rihun rua sanulu resin neen') def test_year_negative(self): self.assertEqual(self.n2w.to_year(-30), 'tolunulu antes Kristu') self.assertEqual( self.n2w.to_year(-744), 'atus hitu haatnulu resin haat antes Kristu' ) self.assertEqual( self.n2w.to_year(-10000), 'rihun sanulu antes Kristu' ) def test_to_ordinal_num(self): self.assertEqual(self.n2w.to_ordinal_num(1), '1º') self.assertEqual(self.n2w.to_ordinal_num(100), '100º') num2words-0.5.14/tests/test_tg.py000066400000000000000000000130731473005321200167270ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsTGTest(TestCase): def test_cardinal(self): with self.assertRaises(OverflowError): num2words(1000000000000000000000000, lang="tg") self.assertEqual(num2words(100, lang="tg"), "сад") self.assertEqual(num2words(100000, lang="tg"), "сад ҳазор") self.assertEqual(num2words(101, lang="tg"), "яксаду як") self.assertEqual(num2words(110, lang="tg"), "яксаду даҳ") self.assertEqual(num2words(115, lang="tg"), "яксаду понздаҳ") self.assertEqual(num2words(123, lang="tg"), "яксаду бисту се") self.assertEqual(num2words(1000, lang="tg"), "як ҳазор") self.assertEqual(num2words(1001, lang="tg"), "як ҳазору як") self.assertEqual(num2words(2012, lang="tg"), "ду ҳазору дувоздаҳ") self.assertEqual( num2words(12519.85, lang="tg"), "дувоздаҳ ҳазору панҷсаду нуздаҳ нуқта ҳашт панҷ", ) self.assertEqual( num2words(1234567890, lang="tg"), "як миллиарду дусаду сию чор миллиону панҷсаду шасту ҳафт ҳазору " "ҳаштсаду навад", ) self.assertEqual(num2words(1000000, lang="tg"), "як миллион") self.assertEqual(num2words(1000000000, lang="tg"), "як миллиард") self.assertEqual(num2words(1000000000000, lang="tg"), "як триллион") self.assertEqual(num2words(5, lang="tg"), "панҷ") self.assertEqual(num2words(-1, lang="tg"), "минус як") self.assertEqual(num2words(-15, lang="tg"), "минус понздаҳ") self.assertEqual(num2words(-100, lang="tg"), "минус сад") def test_to_ordinal(self): self.assertEqual(num2words(1, lang="tg", to="ordinal"), "якум") self.assertEqual(num2words(2, lang="tg", to="ordinal"), "дуюм") self.assertEqual(num2words(3, lang="tg", to="ordinal"), "сеюм") self.assertEqual(num2words(30, lang="tg", to="ordinal"), "сиюм") self.assertEqual(num2words(13, lang="tg", to="ordinal"), "сенздаҳум") self.assertEqual(num2words(20, lang="tg", to="ordinal"), "бистум") self.assertEqual(num2words(23, lang="tg", to="ordinal"), "бисту сеюм") self.assertEqual(num2words(100, lang="tg", to="ordinal"), "садум") self.assertEqual( num2words(136, lang="tg", to="ordinal"), "яксаду сию шашум" ) self.assertEqual(num2words(500, lang="tg", to="ordinal"), "панҷсадум") self.assertEqual( num2words(1000, lang="tg", to="ordinal"), "як ҳазорум" ) self.assertEqual( num2words(1001, lang="tg", to="ordinal"), "як ҳазору якум" ) self.assertEqual( num2words(2000, lang="tg", to="ordinal"), "ду ҳазорум" ) self.assertEqual( num2words(1000000, lang="tg", to="ordinal"), "як миллионум" ) self.assertEqual( num2words(1000000000, lang="tg", to="ordinal"), "як миллиардум" ) def test_to_currency(self): self.assertEqual( num2words(1.0, lang="tg", to="currency", currency="EUR"), "як евро, сифр сент", ) self.assertEqual( num2words(1.0, lang="tg", to="currency", currency="TJS"), "як сомонӣ, сифр дирам", ) self.assertEqual( num2words(1234.56, lang="tg", to="currency", currency="TJS"), "як ҳазору дусаду сию чор сомонӣ, панҷову шаш дирам", ) self.assertEqual( num2words(1234.56, lang="tg", to="currency", currency="RUB"), "як ҳазору дусаду сию чор рубл, панҷову шаш копейк", ) self.assertEqual( num2words( 12519.85, lang="tg", to="currency", currency="TJS", cents=False ), "дувоздаҳ ҳазору панҷсаду нуздаҳ сомонӣ, 85 дирам", ) self.assertEqual( num2words("1230.56", lang="tg", to="currency", currency="USD"), "як ҳазору дусаду си доллар, панҷову шаш сент", ) def test_to_ordinal_num(self): self.assertEqual( num2words("100", lang="tg", to="ordinal_num"), "100ум", ) num2words-0.5.14/tests/test_th.py000066400000000000000000000231161473005321200167270ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words from num2words.lang_TH import Num2Word_TH class TestNumWord(TestCase): def test_0(self): self.assertEqual(num2words(0, lang='th'), "ศูนย์") def test_end_with_1(self): self.assertEqual(num2words(21, lang='th'), "ยี่สิบเอ็ด") self.assertEqual(num2words(11, lang='th'), "สิบเอ็ด") self.assertEqual(num2words(101, lang='th'), "หนึ่งร้อยเอ็ด") self.assertEqual(num2words(1201, lang='th'), "หนึ่งพันสองร้อยเอ็ด") def test_start_20(self): self.assertEqual(num2words(22, lang='th'), "ยี่สิบสอง") self.assertEqual(num2words(27, lang='th'), "ยี่สิบเจ็ด") def test_start_10(self): self.assertEqual(num2words(10, lang='th'), "สิบ") self.assertEqual(num2words(18, lang='th'), "สิบแปด") def test_1_to_9(self): self.assertEqual(num2words(1, lang='th'), "หนึ่ง") self.assertEqual(num2words(5, lang='th'), "ห้า") self.assertEqual(num2words(9, lang='th'), "เก้า") def test_31_to_99(self): self.assertEqual(num2words(31, lang='th'), "สามสิบเอ็ด") self.assertEqual(num2words(48, lang='th'), "สี่สิบแปด") self.assertEqual(num2words(76, lang='th'), "เจ็ดสิบหก") def test_100_to_999(self): self.assertEqual(num2words(100, lang='th'), "หนึ่งร้อย") self.assertEqual(num2words(123, lang='th'), "หนึ่งร้อยยี่สิบสาม") self.assertEqual(num2words(456, lang='th'), "สี่ร้อยห้าสิบหก") self.assertEqual(num2words(721, lang='th'), "เจ็ดร้อยยี่สิบเอ็ด") def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang='th'), "หนึ่งพัน") self.assertEqual( num2words(2175, lang='th'), "สองพันหนึ่งร้อยเจ็ดสิบห้า" ) self.assertEqual(num2words(4582, lang='th'), "สี่พันห้าร้อยแปดสิบสอง") self.assertEqual(num2words(9346, lang='th'), "เก้าพันสามร้อยสี่สิบหก") def test_10000_to_99999(self): self.assertEqual( num2words(11111, lang='th'), "หนึ่งหมื่นหนึ่งพันหนึ่งร้อยสิบเอ็ด" ) self.assertEqual( num2words(22222, lang='th'), "สองหมื่นสองพันสองร้อยยี่สิบสอง" ) self.assertEqual( num2words(84573, lang='th'), "แปดหมื่นสี่พันห้าร้อยเจ็ดสิบสาม" ) def test_100000_to_999999(self): self.assertEqual( num2words(153247, lang='th'), "หนึ่งแสนห้าหมื่นสามพันสองร้อยสี่สิบเจ็ด" ) self.assertEqual( num2words(562442, lang='th'), "ห้าแสนหกหมื่นสองพันสี่ร้อยสี่สิบสอง" ) self.assertEqual( num2words(999999, lang='th'), "เก้าแสนเก้าหมื่นเก้าพันเก้าร้อยเก้าสิบเก้า" ) def test_more_than_million(self): self.assertEqual( num2words(1000000, lang='th'), "หนึ่งล้าน" ) self.assertEqual( num2words(1000001, lang='th'), "หนึ่งล้านเอ็ด" ) self.assertEqual( num2words(42478941, lang='th'), "สี่สิบสองล้านสี่แสนเจ็ดหมื่นแปดพันเก้าร้อยสี่สิบเอ็ด" ) self.assertEqual( num2words(712696969, lang='th'), "เจ็ดร้อยสิบสองล้านหกแสนเก้าหมื่นหกพันเก้าร้อยหกสิบเก้า" ) self.assertEqual( num2words(1000000000000000001, lang='th'), "หนึ่งล้านล้านล้านเอ็ด" ) def test_decimal(self): self.assertEqual( num2words(0.0, lang='th'), "ศูนย์" ) self.assertEqual( num2words(0.0038, lang='th'), "ศูนย์จุดศูนย์ศูนย์สามแปด" ) self.assertEqual( num2words(0.01, lang='th'), "ศูนย์จุดศูนย์หนึ่ง" ) self.assertEqual( num2words(1.123, lang='th'), "หนึ่งจุดหนึ่งสองสาม" ) self.assertEqual( num2words(35.37, lang='th'), "สามสิบห้าจุดสามเจ็ด" ) self.assertEqual( num2words(1000000.01, lang='th'), "หนึ่งล้านจุดศูนย์หนึ่ง" ) def test_currency(self): self.assertEqual( num2words(100, lang='th', to='currency', currency='THB'), "หนึ่งร้อยบาทถ้วน" ) self.assertEqual( num2words(100, lang='th', to='currency', currency='USD'), "หนึ่งร้อยดอลลาร์" ) self.assertEqual( num2words(100, lang='th', to='currency', currency='EUR'), "หนึ่งร้อยยูโร" ) def test_currency_decimal(self): self.assertEqual( num2words(0.00, lang='th', to='currency'), "ศูนย์บาทถ้วน" ) self.assertEqual( num2words(0.05, lang='th', to='currency'), "ห้าสตางค์" ) self.assertEqual( num2words(0.50, lang='th', to='currency'), "ห้าสิบสตางค์" ) self.assertEqual( num2words(0.99, lang='th', to='currency'), "เก้าสิบเก้าสตางค์" ) self.assertEqual( num2words(100.00, lang='th', to='currency'), "หนึ่งร้อยบาทถ้วน" ) self.assertEqual( num2words(100.23, lang='th', to='currency', currency='USD'), "หนึ่งร้อยดอลลาร์ยี่สิบสามเซนต์" ) self.assertEqual( num2words(100.24, lang='th', to='currency', currency='EUR'), "หนึ่งร้อยยูโรยี่สิบสี่เซนต์" ) def test_negative(self): self.assertEqual(num2words(-10, lang='th'), "ติดลบสิบ") self.assertEqual(num2words(-10.50, lang='th'), "ติดลบสิบจุดห้า") self.assertEqual( num2words(-100.00, lang='th', to='currency'), "ติดลบหนึ่งร้อยบาทถ้วน" ) def test_round_2_decimal(self): n2wTH = Num2Word_TH() self.assertEqual(n2wTH.round_2_decimal(0.004), ('0.00', False)) self.assertEqual(n2wTH.round_2_decimal(0.005), ('0.01', False)) self.assertEqual(n2wTH.round_2_decimal(0.006), ('0.01', False)) self.assertEqual(n2wTH.round_2_decimal(0.0005), ('0.00', False)) self.assertEqual(n2wTH.round_2_decimal(0.984), ('0.98', False)) self.assertEqual(n2wTH.round_2_decimal(0.989), ('0.99', False)) self.assertEqual(n2wTH.round_2_decimal(0.994), ('0.99', False)) self.assertEqual(n2wTH.round_2_decimal(0.999), ('1.00', False)) self.assertEqual(n2wTH.round_2_decimal(-0.994), ('0.99', True)) self.assertEqual(n2wTH.round_2_decimal(-0.999), ('1.00', True)) # self.assertEqual(n2wTH.round_2_decimal(0.985), ('0.99', False)) # Expect 0.99 get 0.98 # self.assertEqual(n2wTH.round_2_decimal(0.995), ('1.00', False)) # Expect 1.00 get 0.99 def test_split_six(self): n2wTH = Num2Word_TH() self.assertEqual(n2wTH.split_six(str(123456789)), ['987654', '321']) self.assertEqual(n2wTH.split_six(str(12345)), ['54321']) self.assertEqual(n2wTH.split_six(str(1234567)), ['765432', '1']) num2words-0.5.14/tests/test_tr.py000066400000000000000000000262651473005321200167510ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2017, Tufan Kaynak, Framras. All Rights Reserved. # 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 unittest import TestCase from num2words import num2words class Num2WordsTRTest(TestCase): def test_tr(self): # ref https://github.com/savoirfairelinux/num2words/issues/8 testlang = "tr" testcases = [ {"test": 0, "to": "currency", "expected": u"bedelsiz"}, {"test": 1.1, "to": "currency", "expected": u"birliraonkuruş"}, {"test": 2000, "to": "currency", "expected": u"ikibinlira"}, {"test": 110000, "to": "currency", "expected": u"yüzonbinlira"}, {"test": 1002000, "to": "currency", "expected": u"birmilyonikibinlira"}, {"test": 1002001, "to": "currency", "expected": u"birmilyonikibinbirlira"}, {"test": 1100000, "to": "currency", "expected": u"birmilyonyüzbinlira"}, {"test": 0, "to": "ordinal", "expected": u"sıfırıncı"}, {"test": 1, "to": "ordinal", "expected": u"birinci"}, {"test": 2, "to": "ordinal", "expected": u"ikinci"}, {"test": 9, "to": "ordinal", "expected": u"dokuzuncu"}, {"test": 10, "to": "ordinal", "expected": u"onuncu"}, {"test": 11, "to": "ordinal", "expected": u"onbirinci"}, {"test": 44, "to": "ordinal", "expected": u"kırkdördüncü"}, {"test": 100, "to": "ordinal", "expected": u"yüzüncü"}, {"test": 101, "to": "ordinal", "expected": u"yüzbirinci"}, {"test": 103, "to": "ordinal", "expected": u"yüzüçüncü"}, {"test": 110, "to": "ordinal", "expected": u"yüzonuncu"}, {"test": 111, "to": "ordinal", "expected": u"yüzonbirinci"}, {"test": 1000, "to": "ordinal", "expected": u"bininci"}, {"test": 1001, "to": "ordinal", "expected": u"binbirinci"}, {"test": 1010, "to": "ordinal", "expected": u"binonuncu"}, {"test": 1011, "to": "ordinal", "expected": u"binonbirinci"}, {"test": 1100, "to": "ordinal", "expected": u"binyüzüncü"}, {"test": 1110, "to": "ordinal", "expected": u"binyüzonuncu"}, {"test": 2341, "to": "ordinal", "expected": u"ikibinüçyüzkırkbirinci"}, {"test": 10000, "to": "ordinal", "expected": u"onbininci"}, {"test": 10010, "to": "ordinal", "expected": u"onbinonuncu"}, {"test": 10100, "to": "ordinal", "expected": u"onbinyüzüncü"}, {"test": 10110, "to": "ordinal", "expected": u"onbinyüzonuncu"}, {"test": 11000, "to": "ordinal", "expected": u"onbirbininci"}, {"test": 35000, "to": "ordinal", "expected": u"otuzbeşbininci"}, {"test": 116331, "to": "ordinal", "expected": u"yüzonaltıbinüçyüzotuzbirinci"}, {"test": 116330, "to": "ordinal", "expected": u"yüzonaltıbinüçyüzotuzuncu"}, {"test": 100000, "to": "ordinal", "expected": u"yüzbininci"}, {"test": 501000, "to": "ordinal", "expected": u"beşyüzbirbininci"}, {"test": 1000111, "to": "ordinal", "expected": u"birmilyonyüzonbirinci"}, {"test": 111000111, "to": "ordinal", "expected": u"yüzonbirmilyonyüzonbirinci"}, {"test": 111001111, "to": "ordinal", "expected": u"yüzonbirmilyonbinyüzonbirinci"}, {"test": 111111111, "to": "ordinal", "expected": u"yüzonbirmilyonyüzonbirbinyüzonbirinci"}, {"test": 100001000, "to": "ordinal", "expected": u"yüzmilyonbininci"}, {"test": 100001001, "to": "ordinal", "expected": u"yüzmilyonbinbirinci"}, {"test": 100010000, "to": "ordinal", "expected": u"yüzmilyononbininci"}, {"test": 100010001, "to": "ordinal", "expected": u"yüzmilyononbinbirinci"}, {"test": 100011000, "to": "ordinal", "expected": u"yüzmilyononbirbininci"}, {"test": 100011001, "to": "ordinal", "expected": u"yüzmilyononbirbinbirinci"}, {"test": 101011001, "to": "ordinal", "expected": u"yüzbirmilyononbirbinbirinci"}, {"test": 101011010, "to": "ordinal", "expected": u"yüzbirmilyononbirbinonuncu"}, {"test": 1101011010, "to": "ordinal", "expected": u"birmilyaryüzbirmilyononbirbinonuncu"}, {"test": 101101011010, "to": "ordinal", "expected": u"yüzbirmilyaryüzbirmilyononbirbinonuncu"}, {"test": 1000000000001, "to": "ordinal", "expected": u"birtrilyonbirinci"}, {"test": 1.2, "to": "ordinal", "expected": u""}, {"test": 1.3, "to": "ordinal", "expected": u""}, {"test": 3000, "to": "ordinal", "expected": u"üçbininci"}, {"test": 120000, "to": "ordinal", "expected": u"yüzyirmibininci"}, {"test": 1002002, "to": "ordinal", "expected": u"birmilyonikibinikinci"}, {"test": 1003000, "to": "ordinal", "expected": u"birmilyonüçbininci"}, {"test": 1200000, "to": "ordinal", "expected": u"birmilyonikiyüzbininci"}, {"test": 0, "to": "cardinal", "expected": u"sıfır"}, {"test": 1, "to": "cardinal", "expected": u"bir"}, {"test": 2, "to": "cardinal", "expected": u"iki"}, {"test": 9, "to": "cardinal", "expected": u"dokuz"}, {"test": 10, "to": "cardinal", "expected": u"on"}, {"test": 11, "to": "cardinal", "expected": u"onbir"}, {"test": 44, "to": "cardinal", "expected": u"kırkdört"}, {"test": 100, "to": "cardinal", "expected": u"yüz"}, {"test": 101, "to": "cardinal", "expected": u"yüzbir"}, {"test": 103, "to": "cardinal", "expected": u"yüzüç"}, {"test": 110, "to": "cardinal", "expected": u"yüzon"}, {"test": 111, "to": "cardinal", "expected": u"yüzonbir"}, {"test": 1000, "to": "cardinal", "expected": u"bin"}, {"test": 1001, "to": "cardinal", "expected": u"binbir"}, {"test": 1010, "to": "cardinal", "expected": u"binon"}, {"test": 1011, "to": "cardinal", "expected": u"binonbir"}, {"test": 1100, "to": "cardinal", "expected": u"binyüz"}, {"test": 1110, "to": "cardinal", "expected": u"binyüzon"}, {"test": 2341, "to": "cardinal", "expected": u"ikibinüçyüzkırkbir"}, {"test": 10000, "to": "cardinal", "expected": u"onbin"}, {"test": 10010, "to": "cardinal", "expected": u"onbinon"}, {"test": 10100, "to": "cardinal", "expected": u"onbinyüz"}, {"test": 10110, "to": "cardinal", "expected": u"onbinyüzon"}, {"test": 11000, "to": "cardinal", "expected": u"onbirbin"}, {"test": 35000, "to": "cardinal", "expected": u"otuzbeşbin"}, {"test": 116331, "to": "cardinal", "expected": u"yüzonaltıbinüçyüzotuzbir"}, {"test": 116330, "to": "cardinal", "expected": u"yüzonaltıbinüçyüzotuz"}, {"test": 500000, "to": "cardinal", "expected": u"beşyüzbin"}, {"test": 501000, "to": "cardinal", "expected": u"beşyüzbirbin"}, {"test": 1000111, "to": "cardinal", "expected": u"birmilyonyüzonbir"}, {"test": 111000111, "to": "cardinal", "expected": u"yüzonbirmilyonyüzonbir"}, {"test": 111001111, "to": "cardinal", "expected": u"yüzonbirmilyonbinyüzonbir"}, {"test": 111111111, "to": "cardinal", "expected": u"yüzonbirmilyonyüzonbirbinyüzonbir"}, {"test": 100001000, "to": "cardinal", "expected": u"yüzmilyonbin"}, {"test": 100001001, "to": "cardinal", "expected": u"yüzmilyonbinbir"}, {"test": 100010000, "to": "cardinal", "expected": u"yüzmilyononbin"}, {"test": 100010001, "to": "cardinal", "expected": u"yüzmilyononbinbir"}, {"test": 100011000, "to": "cardinal", "expected": u"yüzmilyononbirbin"}, {"test": 100011001, "to": "cardinal", "expected": u"yüzmilyononbirbinbir"}, {"test": 101011001, "to": "cardinal", "expected": u"yüzbirmilyononbirbinbir"}, {"test": 101011010, "to": "cardinal", "expected": u"yüzbirmilyononbirbinon"}, {"test": 1101011010, "to": "cardinal", "expected": u"birmilyaryüzbirmilyononbirbinon"}, {"test": 101101011010, "to": "cardinal", "expected": u"yüzbirmilyaryüzbirmilyononbirbinon"}, {"test": 1000000000001, "to": "cardinal", "expected": u"birtrilyonbir"}, {"test": 0.01, "to": "cardinal", "expected": u"sıfırvirgülbir"}, {"test": 0.21, "to": "cardinal", "expected": u"sıfırvirgülyirmibir"}, {"test": 0.1, "to": "cardinal", "expected": u"sıfırvirgülon"}, {"test": 1.01, "to": "cardinal", "expected": u"birvirgülbir"}, {"test": 1.1, "to": "cardinal", "expected": u"birvirgülon"}, {"test": 1.21, "to": "cardinal", "expected": u"birvirgülyirmibir"}, {"test": 101101011010.02, "to": "cardinal", "expected": u"yüzbirmilyaryüzbirmilyononbirbinonvirgüliki"}, {"test": 101101011010.2, "to": "cardinal", "expected": u"yüzbirmilyaryüzbirmilyononbirbinonvirgülyirmi"}, {"test": 10, "to": "ordinal_num", "expected": u"10uncu"}, {"test": 1, "to": "ordinal_num", "expected": u"1inci"}, {"test": 3, "to": "ordinal_num", "expected": u"3üncü"}, {"test": 6, "to": "ordinal_num", "expected": u"6ıncı"}, {"test": -5, "to": "cardinal", "expected": u"eksibeş"}, {"test": -55, "to": "cardinal", "expected": u"eksiellibeş"}, {"test": -576, "to": "cardinal", "expected": u"eksibeşyüzyetmişaltı"}, {"test": -3, "to": "currency", "expected": u"eksiüçlira"}, ] for casedata in testcases: self.assertEqual( num2words(casedata["test"], lang=testlang, to=casedata["to"]), casedata["expected"]) num2words-0.5.14/tests/test_uk.py000066400000000000000000006356521473005321200167510ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words TEST_CASES_CARDINAL = ( (1, "один"), (2, "два"), (3, "три"), (4, "чотири"), (5, "п'ять"), (6, "шість"), (7, "сім"), (8, "вісім"), (9, "дев'ять"), (10, "десять"), (10.02, "десять кома нуль два"), (11, "одинадцять"), (12, "дванадцять"), (12.40, "дванадцять кома чотири"), (13, "тринадцять"), (14, "чотирнадцять"), (14.13, "чотирнадцять кома тринадцять"), (15, "п'ятнадцять"), (16, "шістнадцять"), (17, "сімнадцять"), (17.31, "сімнадцять кома тридцять один"), (18, "вісімнадцять"), (19, "дев'ятнадцять"), (20, "двадцять"), (21, "двадцять один"), (21.20, "двадцять один кома два"), (30, "тридцять"), (32, "тридцять два"), (40, "сорок"), (43, "сорок три"), (43.007, "сорок три кома нуль нуль сім"), (50, "п'ятдесят"), (54, "п'ятдесят чотири"), (60, "шістдесят"), (60.059, "шістдесят кома нуль п'ятдесят дев'ять"), (65, "шістдесят п'ять"), (70, "сімдесят"), (76, "сімдесят шість"), (80, "вісімдесят"), (87, "вісімдесят сім"), (90, "дев'яносто"), (98, "дев'яносто вісім"), (99, "дев'яносто дев'ять"), (100, "сто"), (101, "сто один"), (199, "сто дев'яносто дев'ять"), (200, "двісті"), (203, "двісті три"), (300, "триста"), (356, "триста п'ятдесят шість"), (400, "чотириста"), (434, "чотириста тридцять чотири"), (500, "п'ятсот"), (578, "п'ятсот сімдесят вісім"), (600, "шістсот"), (689, "шістсот вісімдесят дев'ять"), (700, "сімсот"), (729, "сімсот двадцять дев'ять"), (800, "вісімсот"), (894, "вісімсот дев'яносто чотири"), (900, "дев'ятсот"), (999, "дев'ятсот дев'яносто дев'ять"), (1000, "одна тисяча"), (1001, "одна тисяча один"), (2012, "дві тисячі дванадцять"), (12519, "дванадцять тисяч п'ятсот дев'ятнадцять"), (12519.85, "дванадцять тисяч п'ятсот дев'ятнадцять кома вісімдесят п'ять"), (-260000, "мінус двісті шістдесят тисяч"), (1000000, "один мільйон"), (1000000000, "один мільярд"), (1234567890, "один мільярд двісті тридцять чотири мільйони " "п'ятсот шістдесят сім тисяч вісімсот дев'яносто"), (1000000000000, "один трильйон"), (1000000000000000, "один квадрильйон"), (1000000000000000000, "один квінтильйон"), (1000000000000000000000, "один секстильйон"), (1000000000000000000000000, "один септильйон"), (1000000000000000000000000000, "один октильйон"), (1000000000000000000000000000000, "один нонільйон"), (215461407892039002157189883901676, "двісті п'ятнадцять нонільйонів чотириста шістдесят один " "октильйон чотириста сім септильйонів вісімсот дев'яносто " "два секстильйони тридцять дев'ять квінтильйонів два " "квадрильйони сто п'ятдесят сім трильйонів сто вісімдесят " "дев'ять мільярдів вісімсот вісімдесят три мільйони " "дев'ятсот одна тисяча шістсот сімдесят шість"), (719094234693663034822824384220291, "сімсот дев'ятнадцять нонільйонів дев'яносто чотири октильйони " "двісті тридцять чотири септильйони шістсот дев'яносто три " "секстильйони шістсот шістдесят три квінтильйони тридцять " "чотири квадрильйони вісімсот двадцять два трильйони вісімсот " "двадцять чотири мільярди триста вісімдесят чотири мільйони " "двісті двадцять тисяч двісті дев'яносто один") ) TEST_CASES_CARDINAL_FEMININE = ( (1, "одна"), (2, "дві"), (3, "три"), (4, "чотири"), (5, "п'ять"), (6, "шість"), (7, "сім"), (8, "вісім"), (9, "дев'ять"), (10, "десять"), (10.02, "десять кома нуль дві"), (11, "одинадцять"), (12, "дванадцять"), (12.40, "дванадцять кома чотири"), (13, "тринадцять"), (14, "чотирнадцять"), (14.13, "чотирнадцять кома тринадцять"), (15, "п'ятнадцять"), (16, "шістнадцять"), (17, "сімнадцять"), (17.31, "сімнадцять кома тридцять одна"), (18, "вісімнадцять"), (19, "дев'ятнадцять"), (20, "двадцять"), (21, "двадцять одна"), (21.20, "двадцять одна кома дві"), (30, "тридцять"), (32, "тридцять дві"), (40, "сорок"), (43, "сорок три"), (43.007, "сорок три кома нуль нуль сім"), (50, "п'ятдесят"), (54, "п'ятдесят чотири"), (60, "шістдесят"), (60.059, "шістдесят кома нуль п'ятдесят дев'ять"), (65, "шістдесят п'ять"), (70, "сімдесят"), (76, "сімдесят шість"), (80, "вісімдесят"), (87, "вісімдесят сім"), (90, "дев'яносто"), (98, "дев'яносто вісім"), (99, "дев'яносто дев'ять"), (100, "сто"), (101, "сто одна"), (199, "сто дев'яносто дев'ять"), (200, "двісті"), (203, "двісті три"), (300, "триста"), (356, "триста п'ятдесят шість"), (400, "чотириста"), (434, "чотириста тридцять чотири"), (500, "п'ятсот"), (578, "п'ятсот сімдесят вісім"), (600, "шістсот"), (689, "шістсот вісімдесят дев'ять"), (700, "сімсот"), (729, "сімсот двадцять дев'ять"), (800, "вісімсот"), (894, "вісімсот дев'яносто чотири"), (900, "дев'ятсот"), (999, "дев'ятсот дев'яносто дев'ять"), (1000, "одна тисяча"), (1001, "одна тисяча одна"), (2012, "дві тисячі дванадцять"), (12519, "дванадцять тисяч п'ятсот дев'ятнадцять"), (12519.85, "дванадцять тисяч п'ятсот дев'ятнадцять кома вісімдесят п'ять"), (-260000, "мінус двісті шістдесят тисяч"), (1000000, "один мільйон"), (1000000000, "один мільярд"), (1234567890, "один мільярд двісті тридцять чотири мільйони " "п'ятсот шістдесят сім тисяч вісімсот дев'яносто"), (1000000000000, "один трильйон"), (1000000000000000, "один квадрильйон"), (1000000000000000000, "один квінтильйон"), (1000000000000000000000, "один секстильйон"), (1000000000000000000000000, "один септильйон"), (1000000000000000000000000000, "один октильйон"), (1000000000000000000000000000000, "один нонільйон"), (215461407892039002157189883901676, "двісті п'ятнадцять нонільйонів чотириста шістдесят один " "октильйон чотириста сім септильйонів вісімсот дев'яносто " "два секстильйони тридцять дев'ять квінтильйонів два " "квадрильйони сто п'ятдесят сім трильйонів сто вісімдесят " "дев'ять мільярдів вісімсот вісімдесят три мільйони " "дев'ятсот одна тисяча шістсот сімдесят шість"), (719094234693663034822824384220291, "сімсот дев'ятнадцять нонільйонів дев'яносто чотири октильйони " "двісті тридцять чотири септильйони шістсот дев'яносто три " "секстильйони шістсот шістдесят три квінтильйони тридцять " "чотири квадрильйони вісімсот двадцять два трильйони вісімсот " "двадцять чотири мільярди триста вісімдесят чотири мільйони " "двісті двадцять тисяч двісті дев'яносто одна") ) TEST_CASES_CARDINAL_GENITIVE = ( (1, "одного"), (2, "двох"), (3, "трьох"), (4, "чотирьох"), (5, "п'яти"), (6, "шести"), (7, "семи"), (8, "восьми"), (9, "дев'яти"), (10, "десяти"), (10.02, "десяти кома нуль двох"), (11, "одинадцяти"), (12, "дванадцяти"), (12.40, "дванадцяти кома чотирьох"), (13, "тринадцяти"), (14, "чотирнадцяти"), (14.13, "чотирнадцяти кома тринадцяти"), (15, "п'ятнадцяти"), (16, "шістнадцяти"), (17, "сімнадцяти"), (17.31, "сімнадцяти кома тридцяти одного"), (18, "вісімнадцяти"), (19, "дев'ятнадцяти"), (20, "двадцяти"), (21, "двадцяти одного"), (21.20, "двадцяти одного кома двох"), (30, "тридцяти"), (32, "тридцяти двох"), (40, "сорока"), (43, "сорока трьох"), (43.007, "сорока трьох кома нуль нуль семи"), (50, "п'ятдесяти"), (54, "п'ятдесяти чотирьох"), (60, "шістдесяти"), (60.059, "шістдесяти кома нуль п'ятдесяти дев'яти"), (65, "шістдесяти п'яти"), (70, "сімдесяти"), (76, "сімдесяти шести"), (80, "вісімдесяти"), (87, "вісімдесяти семи"), (90, "дев'яноста"), (98, "дев'яноста восьми"), (99, "дев'яноста дев'яти"), (100, "ста"), (101, "ста одного"), (199, "ста дев'яноста дев'яти"), (200, "двохста"), (203, "двохста трьох"), (300, "трьохста"), (356, "трьохста п'ятдесяти шести"), (400, "чотирьохста"), (434, "чотирьохста тридцяти чотирьох"), (500, "п'ятиста"), (578, "п'ятиста сімдесяти восьми"), (600, "шестиста"), (689, "шестиста вісімдесяти дев'яти"), (700, "семиста"), (729, "семиста двадцяти дев'яти"), (800, "восьмиста"), (894, "восьмиста дев'яноста чотирьох"), (900, "дев'ятиста"), (999, "дев'ятиста дев'яноста дев'яти"), (1000, "однієї тисячи"), (1001, "однієї тисячи одного"), (2012, "двох тисяч дванадцяти"), (12519, "дванадцяти тисяч п'ятиста дев'ятнадцяти"), (12519.85, "дванадцяти тисяч п'ятиста дев'ятнадцяти " "кома вісімдесяти п'яти"), (-260000, "мінус двохста шістдесяти тисяч"), (1000000, "одного мільйона"), (1000000000, "одного мільярда"), (1234567890, "одного мільярда двохста тридцяти чотирьох мільйонів " "п'ятиста шістдесяти семи тисяч восьмиста дев'яноста"), (1000000000000, "одного трильйона"), (1000000000000000, "одного квадрильйона"), (1000000000000000000, "одного квінтильйона"), (1000000000000000000000, "одного секстильйона"), (1000000000000000000000000, "одного септильйона"), (1000000000000000000000000000, "одного октильйона"), (1000000000000000000000000000000, "одного нонільйона"), (215461407892039002157189883901676, "двохста п'ятнадцяти нонільйонів чотирьохста шістдесяти одного " "октильйона чотирьохста семи септильйонів восьмиста дев'яноста " "двох секстильйонів тридцяти дев'яти квінтильйонів двох " "квадрильйонів ста п'ятдесяти семи трильйонів ста вісімдесяти " "дев'яти мільярдів восьмиста вісімдесяти трьох мільйонів " "дев'ятиста однієї тисячи шестиста сімдесяти шести"), (719094234693663034822824384220291, "семиста дев'ятнадцяти нонільйонів дев'яноста чотирьох октильйонів " "двохста тридцяти чотирьох септильйонів шестиста дев'яноста трьох " "секстильйонів шестиста шістдесяти трьох квінтильйонів тридцяти " "чотирьох квадрильйонів восьмиста двадцяти двох трильйонів восьмиста " "двадцяти чотирьох мільярдів трьохста вісімдесяти чотирьох мільйонів " "двохста двадцяти тисяч двохста дев'яноста одного") ) TEST_CASES_CARDINAL_DATIVE = ( (1, "одному"), (2, "двом"), (3, "трьом"), (4, "чотирьом"), (5, "п'яти"), (6, "шести"), (7, "семи"), (8, "восьми"), (9, "дев'яти"), (10, "десяти"), (10.02, "десяти кома нуль двом"), (11, "одинадцяти"), (12, "дванадцяти"), (12.40, "дванадцяти кома чотирьом"), (13, "тринадцяти"), (14, "чотирнадцяти"), (14.13, "чотирнадцяти кома тринадцяти"), (15, "п'ятнадцяти"), (16, "шістнадцяти"), (17, "сімнадцяти"), (17.31, "сімнадцяти кома тридцяти одному"), (18, "вісімнадцяти"), (19, "дев'ятнадцяти"), (20, "двадцяти"), (21, "двадцяти одному"), (21.20, "двадцяти одному кома двом"), (30, "тридцяти"), (32, "тридцяти двом"), (40, "сорока"), (43, "сорока трьом"), (43.007, "сорока трьом кома нуль нуль семи"), (50, "п'ятдесяти"), (54, "п'ятдесяти чотирьом"), (60, "шістдесяти"), (60.059, "шістдесяти кома нуль п'ятдесяти дев'яти"), (65, "шістдесяти п'яти"), (70, "сімдесяти"), (76, "сімдесяти шести"), (80, "вісімдесяти"), (87, "вісімдесяти семи"), (90, "дев'яноста"), (98, "дев'яноста восьми"), (99, "дев'яноста дев'яти"), (100, "ста"), (101, "ста одному"), (199, "ста дев'яноста дев'яти"), (200, "двомстам"), (203, "двомстам трьом"), (300, "трьомстам"), (356, "трьомстам п'ятдесяти шести"), (400, "чотирьомстам"), (434, "чотирьомстам тридцяти чотирьом"), (500, "п'ятистам"), (578, "п'ятистам сімдесяти восьми"), (600, "шестистам"), (689, "шестистам вісімдесяти дев'яти"), (700, "семистам"), (729, "семистам двадцяти дев'яти"), (800, "восьмистам"), (894, "восьмистам дев'яноста чотирьом"), (900, "дев'ятистам"), (999, "дев'ятистам дев'яноста дев'яти"), (1000, "одній тисячі"), (1001, "одній тисячі одному"), (2012, "двом тисячам дванадцяти"), (12519, "дванадцяти тисячам п'ятистам дев'ятнадцяти"), (12519.85, "дванадцяти тисячам п'ятистам дев'ятнадцяти " "кома вісімдесяти п'яти"), (-260000, "мінус двомстам шістдесяти тисячам"), (1000000, "одному мільйону"), (1000000000, "одному мільярду"), (1234567890, "одному мільярду двомстам тридцяти чотирьом мільйонам " "п'ятистам шістдесяти семи тисячам восьмистам дев'яноста"), (1000000000000, "одному трильйону"), (1000000000000000, "одному квадрильйону"), (1000000000000000000, "одному квінтильйону"), (1000000000000000000000, "одному секстильйону"), (1000000000000000000000000, "одному септильйону"), (1000000000000000000000000000, "одному октильйону"), (1000000000000000000000000000000, "одному нонільйону"), (215461407892039002157189883901676, "двомстам п'ятнадцяти нонільйонам чотирьомстам шістдесяти одному " "октильйону чотирьомстам семи септильйонам восьмистам дев'яноста " "двом секстильйонам тридцяти дев'яти квінтильйонам двом " "квадрильйонам ста п'ятдесяти семи трильйонам ста вісімдесяти " "дев'яти мільярдам восьмистам вісімдесяти трьом мільйонам " "дев'ятистам одній тисячі шестистам сімдесяти шести"), (719094234693663034822824384220291, "семистам дев'ятнадцяти нонільйонам дев'яноста чотирьом октильйонам " "двомстам тридцяти чотирьом септильйонам шестистам дев'яноста трьом " "секстильйонам шестистам шістдесяти трьом квінтильйонам тридцяти " "чотирьом квадрильйонам восьмистам двадцяти двом трильйонам восьмистам " "двадцяти чотирьом мільярдам трьомстам вісімдесяти чотирьом мільйонам " "двомстам двадцяти тисячам двомстам дев'яноста одному") ) TEST_CASES_CARDINAL_ACCUSATIVE = ( (1, "один"), (2, "два"), (3, "три"), (4, "чотири"), (5, "п'ять"), (6, "шість"), (7, "сім"), (8, "вісім"), (9, "дев'ять"), (10, "десять"), (10.02, "десять кома нуль два"), (11, "одинадцять"), (12, "дванадцять"), (12.40, "дванадцять кома чотири"), (13, "тринадцять"), (14, "чотирнадцять"), (14.13, "чотирнадцять кома тринадцять"), (15, "п'ятнадцять"), (16, "шістнадцять"), (17, "сімнадцять"), (17.31, "сімнадцять кома тридцять один"), (18, "вісімнадцять"), (19, "дев'ятнадцять"), (20, "двадцять"), (21, "двадцять один"), (21.20, "двадцять один кома два"), (30, "тридцять"), (32, "тридцять два"), (40, "сорок"), (43, "сорок три"), (43.007, "сорок три кома нуль нуль сім"), (50, "п'ятдесят"), (54, "п'ятдесят чотири"), (60, "шістдесят"), (60.059, "шістдесят кома нуль п'ятдесят дев'ять"), (65, "шістдесят п'ять"), (70, "сімдесят"), (76, "сімдесят шість"), (80, "вісімдесят"), (87, "вісімдесят сім"), (90, "дев'яносто"), (98, "дев'яносто вісім"), (99, "дев'яносто дев'ять"), (100, "сто"), (101, "сто один"), (199, "сто дев'яносто дев'ять"), (200, "двісті"), (203, "двісті три"), (300, "триста"), (356, "триста п'ятдесят шість"), (400, "чотириста"), (434, "чотириста тридцять чотири"), (500, "п'ятсот"), (578, "п'ятсот сімдесят вісім"), (600, "шістсот"), (689, "шістсот вісімдесят дев'ять"), (700, "сімсот"), (729, "сімсот двадцять дев'ять"), (800, "вісімсот"), (894, "вісімсот дев'яносто чотири"), (900, "дев'ятсот"), (999, "дев'ятсот дев'яносто дев'ять"), (1000, "одну тисячу"), (1001, "одну тисячу один"), (2012, "дві тисячі дванадцять"), (12519, "дванадцять тисяч п'ятсот дев'ятнадцять"), (12519.85, "дванадцять тисяч п'ятсот дев'ятнадцять кома вісімдесят п'ять"), (-260000, "мінус двісті шістдесят тисяч"), (1000000, "один мільйон"), (1000000000, "один мільярд"), (1234567890, "один мільярд двісті тридцять чотири мільйони " "п'ятсот шістдесят сім тисяч вісімсот дев'яносто"), (1000000000000, "один трильйон"), (1000000000000000, "один квадрильйон"), (1000000000000000000, "один квінтильйон"), (1000000000000000000000, "один секстильйон"), (1000000000000000000000000, "один септильйон"), (1000000000000000000000000000, "один октильйон"), (1000000000000000000000000000000, "один нонільйон"), (215461407892039002157189883901676, "двісті п'ятнадцять нонільйонів чотириста шістдесят один " "октильйон чотириста сім септильйонів вісімсот дев'яносто " "два секстильйони тридцять дев'ять квінтильйонів два " "квадрильйони сто п'ятдесят сім трильйонів сто вісімдесят " "дев'ять мільярдів вісімсот вісімдесят три мільйони " "дев'ятсот одну тисячу шістсот сімдесят шість"), (719094234693663034822824384220291, "сімсот дев'ятнадцять нонільйонів дев'яносто чотири октильйони " "двісті тридцять чотири септильйони шістсот дев'яносто три " "секстильйони шістсот шістдесят три квінтильйони тридцять " "чотири квадрильйони вісімсот двадцять два трильйони вісімсот " "двадцять чотири мільярди триста вісімдесят чотири мільйони " "двісті двадцять тисяч двісті дев'яносто один") ) TEST_CASES_CARDINAL_INSTRUMENTAL = ( (1, "одним"), (2, "двома"), (3, "трьома"), (4, "чотирма"), (5, "п'ятьма"), (6, "шістьма"), (7, "сьома"), (8, "вісьма"), (9, "дев'ятьма"), (10, "десятьма"), (10.02, "десятьма кома нуль двома"), (11, "одинадцятьма"), (12, "дванадцятьма"), (12.40, "дванадцятьма кома чотирма"), (13, "тринадцятьма"), (14, "чотирнадцятьма"), (14.13, "чотирнадцятьма кома тринадцятьма"), (15, "п'ятнадцятьма"), (16, "шістнадцятьма"), (17, "сімнадцятьма"), (17.31, "сімнадцятьма кома тридцятьма одним"), (18, "вісімнадцятьма"), (19, "дев'ятнадцятьма"), (20, "двадцятьма"), (21, "двадцятьма одним"), (21.20, "двадцятьма одним кома двома"), (30, "тридцятьма"), (32, "тридцятьма двома"), (40, "сорока"), (43, "сорока трьома"), (43.007, "сорока трьома кома нуль нуль сьома"), (50, "п'ятдесятьма"), (54, "п'ятдесятьма чотирма"), (60, "шістдесятьма"), (60.059, "шістдесятьма кома нуль п'ятдесятьма дев'ятьма"), (65, "шістдесятьма п'ятьма"), (70, "сімдесятьма"), (76, "сімдесятьма шістьма"), (80, "вісімдесятьма"), (87, "вісімдесятьма сьома"), (90, "дев'яностами"), (98, "дев'яностами вісьма"), (99, "дев'яностами дев'ятьма"), (100, "стами"), (101, "стами одним"), (199, "стами дев'яностами дев'ятьма"), (200, "двомастами"), (203, "двомастами трьома"), (300, "трьомастами"), (356, "трьомастами п'ятдесятьма шістьма"), (400, "чотирмастами"), (434, "чотирмастами тридцятьма чотирма"), (500, "п'ятьмастами"), (578, "п'ятьмастами сімдесятьма вісьма"), (600, "шістьмастами"), (689, "шістьмастами вісімдесятьма дев'ятьма"), (700, "сьомастами"), (729, "сьомастами двадцятьма дев'ятьма"), (800, "восьмастами"), (894, "восьмастами дев'яностами чотирма"), (900, "дев'ятьмастами"), (999, "дев'ятьмастами дев'яностами дев'ятьма"), (1000, "однією тисячею"), (1001, "однією тисячею одним"), (2012, "двома тисячами дванадцятьма"), (12519, "дванадцятьма тисячами п'ятьмастами дев'ятнадцятьма"), (12519.85, "дванадцятьма тисячами п'ятьмастами дев'ятнадцятьма " "кома вісімдесятьма п'ятьма"), (-260000, "мінус двомастами шістдесятьма тисячами"), (1000000, "одним мільйоном"), (1000000000, "одним мільярдом"), (1234567890, "одним мільярдом двомастами тридцятьма чотирма мільйонами " "п'ятьмастами шістдесятьма сьома тисячами восьмастами " "дев'яностами"), (1000000000000, "одним трильйоном"), (1000000000000000, "одним квадрильйоном"), (1000000000000000000, "одним квінтильйоном"), (1000000000000000000000, "одним секстильйоном"), (1000000000000000000000000, "одним септильйоном"), (1000000000000000000000000000, "одним октильйоном"), (1000000000000000000000000000000, "одним нонільйоном"), (215461407892039002157189883901676, "двомастами п'ятнадцятьма нонільйонів чотирмастами шістдесятьма одним " "октильйоном чотирмастами сьома септильйонів восьмастами дев'яностами " "двома секстильйонами тридцятьма дев'ятьма квінтильйонів двома " "квадрильйонами стами п'ятдесятьма сьома трильйонів стами вісімдесятьма " "дев'ятьма мільярдів восьмастами вісімдесятьма трьома мільйонами " "дев'ятьмастами однією тисячею шістьмастами сімдесятьма шістьма"), (719094234693663034822824384220291, "сьомастами дев'ятнадцятьма нонільйонів дев'яностами чотирма " "октильйонами двомастами тридцятьма чотирма септильйонами шістьмастами " "дев'яностами трьома секстильйонами шістьмастами шістдесятьма трьома " "квінтильйонами тридцятьма чотирма квадрильйонами восьмастами двадцятьма " "двома трильйонами восьмастами двадцятьма чотирма мільярдами трьомастами " "вісімдесятьма чотирма мільйонами двомастами двадцятьма тисячами " "двомастами дев'яностами одним") ) TEST_CASES_CARDINAL_LOCATIVE = ( (1, "одному"), (2, "двох"), (3, "трьох"), (4, "чотирьох"), (5, "п'яти"), (6, "шести"), (7, "семи"), (8, "восьми"), (9, "дев'яти"), (10, "десяти"), (10.02, "десяти кома нуль двох"), (11, "одинадцяти"), (12, "дванадцяти"), (12.40, "дванадцяти кома чотирьох"), (13, "тринадцяти"), (14, "чотирнадцяти"), (14.13, "чотирнадцяти кома тринадцяти"), (15, "п'ятнадцяти"), (16, "шістнадцяти"), (17, "сімнадцяти"), (17.31, "сімнадцяти кома тридцяти одному"), (18, "вісімнадцяти"), (19, "дев'ятнадцяти"), (20, "двадцяти"), (21, "двадцяти одному"), (21.20, "двадцяти одному кома двох"), (30, "тридцяти"), (32, "тридцяти двох"), (40, "сорока"), (43, "сорока трьох"), (43.007, "сорока трьох кома нуль нуль семи"), (50, "п'ятдесяти"), (54, "п'ятдесяти чотирьох"), (60, "шістдесяти"), (60.059, "шістдесяти кома нуль п'ятдесяти дев'яти"), (65, "шістдесяти п'яти"), (70, "сімдесяти"), (76, "сімдесяти шести"), (80, "вісімдесяти"), (87, "вісімдесяти семи"), (90, "дев'яноста"), (98, "дев'яноста восьми"), (99, "дев'яноста дев'яти"), (100, "стах"), (101, "стах одному"), (199, "стах дев'яноста дев'яти"), (200, "двохстах"), (203, "двохстах трьох"), (300, "трьохстах"), (356, "трьохстах п'ятдесяти шести"), (400, "чотирьохстах"), (434, "чотирьохстах тридцяти чотирьох"), (500, "п'ятистах"), (578, "п'ятистах сімдесяти восьми"), (600, "шестистах"), (689, "шестистах вісімдесяти дев'яти"), (700, "семистах"), (729, "семистах двадцяти дев'яти"), (800, "восьмистах"), (894, "восьмистах дев'яноста чотирьох"), (900, "дев'ятистах"), (999, "дев'ятистах дев'яноста дев'яти"), (1000, "одній тисячі"), (1001, "одній тисячі одному"), (2012, "двох тисячах дванадцяти"), (12519, "дванадцяти тисячах п'ятистах дев'ятнадцяти"), (12519.85, "дванадцяти тисячах п'ятистах дев'ятнадцяти " "кома вісімдесяти п'яти"), (-260000, "мінус двохстах шістдесяти тисячах"), (1000000, "одному мільйоні"), (1000000000, "одному мільярді"), (1234567890, "одному мільярді двохстах тридцяти чотирьох мільйонах " "п'ятистах шістдесяти семи тисячах восьмистах дев'яноста"), (1000000000000, "одному трильйоні"), (1000000000000000, "одному квадрильйоні"), (1000000000000000000, "одному квінтильйоні"), (1000000000000000000000, "одному секстильйоні"), (1000000000000000000000000, "одному септильйоні"), (1000000000000000000000000000, "одному октильйоні"), (1000000000000000000000000000000, "одному нонільйоні"), (215461407892039002157189883901676, "двохстах п'ятнадцяти нонільйонах чотирьохстах шістдесяти одному " "октильйоні чотирьохстах семи септильйонах восьмистах дев'яноста " "двох секстильйонах тридцяти дев'яти квінтильйонах двох " "квадрильйонах стах п'ятдесяти семи трильйонах стах вісімдесяти " "дев'яти мільярдах восьмистах вісімдесяти трьох мільйонах " "дев'ятистах одній тисячі шестистах сімдесяти шести"), (719094234693663034822824384220291, "семистах дев'ятнадцяти нонільйонах дев'яноста чотирьох октильйонах " "двохстах тридцяти чотирьох септильйонах шестистах дев'яноста трьох " "секстильйонах шестистах шістдесяти трьох квінтильйонах тридцяти " "чотирьох квадрильйонах восьмистах двадцяти двох трильйонах восьмистах " "двадцяти чотирьох мільярдах трьохстах вісімдесяти чотирьох мільйонах " "двохстах двадцяти тисячах двохстах дев'яноста одному") ) TEST_CASES_ORDINAL = ( (1, "перший"), (2, "другий"), (3, "третій"), (4, "четвертий"), (5, "п'ятий"), (6, "шостий"), (7, "сьомий"), (8, "восьмий"), (9, "дев'ятий"), (10, "десятий"), (11, "одинадцятий"), (12, "дванадцятий"), (13, "тринадцятий"), (14, "чотирнадцятий"), (15, "п'ятнадцятий"), (16, "шістнадцятий"), (17, "сімнадцятий"), (18, "вісімнадцятий"), (19, "дев'ятнадцятий"), (20, "двадцятий"), (21, "двадцять перший"), (30, "тридцятий"), (32, "тридцять другий"), (40, "сороковий"), (43, "сорок третій"), (50, "п'ятдесятий"), (54, "п'ятдесят четвертий"), (60, "шістдесятий"), (65, "шістдесят п'ятий"), (70, "сімдесятий"), (76, "сімдесят шостий"), (80, "вісімдесятий"), (87, "вісімдесят сьомий"), (90, "дев'яностий"), (98, "дев'яносто восьмий"), (100, "сотий"), (101, "сто перший"), (199, "сто дев'яносто дев'ятий"), (200, "двохсотий"), (203, "двісті третій"), (300, "трьохсотий"), (356, "триста п'ятдесят шостий"), (400, "чотирьохсотий"), (434, "чотириста тридцять четвертий"), (500, "п'ятисотий"), (578, "п'ятсот сімдесят восьмий"), (600, "шестисотий"), (690, "шістсот дев'яностий"), (700, "семисотий"), (729, "сімсот двадцять дев'ятий"), (800, "восьмисотий"), (894, "вісімсот дев'яносто четвертий"), (900, "дев'ятисотий"), (999, "дев'ятсот дев'яносто дев'ятий"), (1000, "тисячний"), (1001, "одна тисяча перший"), (2000, "двохтисячний"), (2312, "дві тисячі триста дванадцятий"), (12000, "дванадцятитисячний"), (25000, "двадцятип'ятитисячний"), (213000, "двохсоттринадцятитисячний"), (256000, "двохсотп'ятдесятишеститисячний"), (260000, "двохсотшістдесятитисячний"), (1000000, "мільйонний"), (589000000, "п'ятсотвісімдесятидев'ятимільйонний"), (1000000000, "мільярдний"), (1234567890, "один мільярд двісті тридцять чотири мільйони " "п'ятсот шістдесят сім тисяч вісімсот дев'яностий"), (1000000000000, "трильйонний"), (1000000000000000, "квадрильйонний"), (1000000000000000000, "квінтильйонний"), (1000000000000000000000, "секстильйонний"), (1000000000000000000000000, "септильйонний"), (1000000000000000000000000000, "октильйонний"), (1000000000000000000000000000000, "нонільйонний"), (956000000000000000000000000000000, "дев'ятсотп'ятдесятишестинонільйонний"), ) TEST_CASES_TO_CURRENCY_AED = ( (0.00, "нуль дирхамів, нуль філсів"), (1.00, "один дирхам, нуль філсів"), (2.00, "два дирхами, нуль філсів"), (5.00, "п'ять дирхамів, нуль філсів"), (11.00, "одинадцять дирхамів, нуль філсів"), (16.01, "шістнадцять дирхамів, один філс"), (21.00, "двадцять один дирхам, нуль філсів"), (37.73, "тридцять сім дирхамів, сімдесят три філси"), (81.25, "вісімдесят один дирхам, двадцять п'ять філсів"), (100.00, "сто дирхамів, нуль філсів"), (101.11, "сто один дирхам, одинадцять філсів"), (10222, "сто два дирхами, двадцять два філси"), ) TEST_CASES_TO_CURRENCY_AFN = ( (0.00, "нуль афгані, нуль пулів"), (1.00, "один афгані, нуль пулів"), (2.00, "два афгані, нуль пулів"), (5.00, "п'ять афгані, нуль пулів"), (11.00, "одинадцять афгані, нуль пулів"), (16.01, "шістнадцять афгані, один пул"), (21.00, "двадцять один афгані, нуль пулів"), (37.73, "тридцять сім афгані, сімдесят три пули"), (81.25, "вісімдесят один афгані, двадцять п'ять пулів"), (100.00, "сто афгані, нуль пулів"), (101.11, "сто один афгані, одинадцять пулів"), (10222, "сто два афгані, двадцять два пули"), ) TEST_CASES_TO_CURRENCY_ALL = ( (0.00, "нуль леків, нуль кіндарок"), (1.00, "один лек, нуль кіндарок"), (2.00, "два леки, нуль кіндарок"), (5.00, "п'ять леків, нуль кіндарок"), (11.00, "одинадцять леків, нуль кіндарок"), (16.01, "шістнадцять леків, одна кіндарка"), (21.00, "двадцять один лек, нуль кіндарок"), (37.73, "тридцять сім леків, сімдесят три кіндарки"), (81.25, "вісімдесят один лек, двадцять п'ять кіндарок"), (100.00, "сто леків, нуль кіндарок"), (101.11, "сто один лек, одинадцять кіндарок"), (10222, "сто два леки, двадцять дві кіндарки"), ) TEST_CASES_TO_CURRENCY_AMD = ( (0.00, "нуль драмів, нуль лум"), (1.00, "один драм, нуль лум"), (2.00, "два драми, нуль лум"), (5.00, "п'ять драмів, нуль лум"), (11.00, "одинадцять драмів, нуль лум"), (16.01, "шістнадцять драмів, один лум"), (21.00, "двадцять один драм, нуль лум"), (37.73, "тридцять сім драмів, сімдесят три лум"), (81.25, "вісімдесят один драм, двадцять п'ять лум"), (100.00, "сто драмів, нуль лум"), (101.11, "сто один драм, одинадцять лум"), (10222, "сто два драми, двадцять два лум"), ) TEST_CASES_TO_CURRENCY_ANG = ( (0.00, "нуль гульденів, нуль центів"), (1.00, "один гульден, нуль центів"), (2.00, "два гульдени, нуль центів"), (5.00, "п'ять гульденів, нуль центів"), (11.00, "одинадцять гульденів, нуль центів"), (16.01, "шістнадцять гульденів, один цент"), (21.00, "двадцять один гульден, нуль центів"), (37.73, "тридцять сім гульденів, сімдесят три центи"), (81.25, "вісімдесят один гульден, двадцять п'ять центів"), (100.00, "сто гульденів, нуль центів"), (101.11, "сто один гульден, одинадцять центів"), (10222, "сто два гульдени, двадцять два центи"), ) # TEST_CASES_TO_CURRENCY_AOA = ( (0.00, "нуль кванз, нуль сентимо"), (1.00, "одна кванза, нуль сентимо"), (2.00, "дві кванзи, нуль сентимо"), (5.00, "п'ять кванз, нуль сентимо"), (11.00, "одинадцять кванз, нуль сентимо"), (16.01, "шістнадцять кванз, один сентимо"), (21.00, "двадцять одна кванза, нуль сентимо"), (37.73, "тридцять сім кванз, сімдесят три сентимо"), (81.25, "вісімдесят одна кванза, двадцять п'ять сентимо"), (100.00, "сто кванз, нуль сентимо"), (101.11, "сто одна кванза, одинадцять сентимо"), (10222, "сто дві кванзи, двадцять два сентимо"), ) # TEST_CASES_TO_CURRENCY_ARS = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) # TEST_CASES_TO_CURRENCY_AUD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) # TEST_CASES_TO_CURRENCY_AWG = ( (0.00, "нуль флоринів, нуль центів"), (1.00, "один флорин, нуль центів"), (2.00, "два флорини, нуль центів"), (5.00, "п'ять флоринів, нуль центів"), (11.00, "одинадцять флоринів, нуль центів"), (16.01, "шістнадцять флоринів, один цент"), (21.00, "двадцять один флорин, нуль центів"), (37.73, "тридцять сім флоринів, сімдесят три центи"), (81.25, "вісімдесят один флорин, двадцять п'ять центів"), (100.00, "сто флоринів, нуль центів"), (101.11, "сто один флорин, одинадцять центів"), (10222, "сто два флорини, двадцять два центи"), ) # TEST_CASES_TO_CURRENCY_AZN = ( (0.00, "нуль манатів, нуль гяпіків"), (1.00, "один манат, нуль гяпіків"), (2.00, "два манати, нуль гяпіків"), (5.00, "п'ять манатів, нуль гяпіків"), (11.00, "одинадцять манатів, нуль гяпіків"), (16.01, "шістнадцять манатів, один гяпік"), (21.00, "двадцять один манат, нуль гяпіків"), (37.73, "тридцять сім манатів, сімдесят три гяпіки"), (81.25, "вісімдесят один манат, двадцять п'ять гяпіків"), (100.00, "сто манатів, нуль гяпіків"), (101.11, "сто один манат, одинадцять гяпіків"), (10222, "сто два манати, двадцять два гяпіки"), ) # TEST_CASES_TO_CURRENCY_BAM = ( (0.00, "нуль марок, нуль фенінгів"), (1.00, "одна марка, нуль фенінгів"), (2.00, "дві марки, нуль фенінгів"), (5.00, "п'ять марок, нуль фенінгів"), (11.00, "одинадцять марок, нуль фенінгів"), (16.01, "шістнадцять марок, один фенінг"), (21.00, "двадцять одна марка, нуль фенінгів"), (37.73, "тридцять сім марок, сімдесят три фенінги"), (81.25, "вісімдесят одна марка, двадцять п'ять фенінгів"), (100.00, "сто марок, нуль фенінгів"), (101.11, "сто одна марка, одинадцять фенінгів"), (10222, "сто дві марки, двадцять два фенінги"), ) # TEST_CASES_TO_CURRENCY_BBD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_BDT = ( (0.00, "нуль так, нуль пойш"), (1.00, "одна така, нуль пойш"), (2.00, "дві таки, нуль пойш"), (5.00, "п'ять так, нуль пойш"), (11.00, "одинадцять так, нуль пойш"), (16.01, "шістнадцять так, одна пойша"), (21.00, "двадцять одна така, нуль пойш"), (37.73, "тридцять сім так, сімдесят три пойші"), (81.25, "вісімдесят одна така, двадцять п'ять пойш"), (100.00, "сто так, нуль пойш"), (101.11, "сто одна така, одинадцять пойш"), (10222, "сто дві таки, двадцять дві пойші"), ) TEST_CASES_TO_CURRENCY_BGN = ( (0.00, "нуль левів, нуль стотинок"), (1.00, "один лев, нуль стотинок"), (2.00, "два леви, нуль стотинок"), (5.00, "п'ять левів, нуль стотинок"), (11.00, "одинадцять левів, нуль стотинок"), (16.01, "шістнадцять левів, одна стотинка"), (21.00, "двадцять один лев, нуль стотинок"), (37.73, "тридцять сім левів, сімдесят три стотинки"), (81.25, "вісімдесят один лев, двадцять п'ять стотинок"), (100.00, "сто левів, нуль стотинок"), (101.11, "сто один лев, одинадцять стотинок"), (10222, "сто два леви, двадцять дві стотинки"), ) TEST_CASES_TO_CURRENCY_BHD = ( (0.00, "нуль динарів, нуль філсів"), (1.00, "один динар, нуль філсів"), (2.00, "два динари, нуль філсів"), (5.00, "п'ять динарів, нуль філсів"), (11.00, "одинадцять динарів, нуль філсів"), (16.01, "шістнадцять динарів, один філс"), (21.00, "двадцять один динар, нуль філсів"), (37.73, "тридцять сім динарів, сімдесят три філси"), (81.25, "вісімдесят один динар, двадцять п'ять філсів"), (100.00, "сто динарів, нуль філсів"), (101.11, "сто один динар, одинадцять філсів"), (10222, "сто два динари, двадцять два філси"), ) TEST_CASES_TO_CURRENCY_BIF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_BMD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_BND = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_BOB = ( (0.00, "нуль болівіано, нуль сентаво"), (1.00, "один болівіано, нуль сентаво"), (2.00, "два болівіано, нуль сентаво"), (5.00, "п'ять болівіано, нуль сентаво"), (11.00, "одинадцять болівіано, нуль сентаво"), (16.01, "шістнадцять болівіано, один сентаво"), (21.00, "двадцять один болівіано, нуль сентаво"), (37.73, "тридцять сім болівіано, сімдесят три сентаво"), (81.25, "вісімдесят один болівіано, двадцять п'ять сентаво"), (100.00, "сто болівіано, нуль сентаво"), (101.11, "сто один болівіано, одинадцять сентаво"), (10222, "сто два болівіано, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_BRL = ( (0.00, "нуль реалів, нуль сентаво"), (1.00, "один реал, нуль сентаво"), (2.00, "два реали, нуль сентаво"), (5.00, "п'ять реалів, нуль сентаво"), (11.00, "одинадцять реалів, нуль сентаво"), (16.01, "шістнадцять реалів, один сентаво"), (21.00, "двадцять один реал, нуль сентаво"), (37.73, "тридцять сім реалів, сімдесят три сентаво"), (81.25, "вісімдесят один реал, двадцять п'ять сентаво"), (100.00, "сто реалів, нуль сентаво"), (101.11, "сто один реал, одинадцять сентаво"), (10222, "сто два реали, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_BSD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_BTN = ( (0.00, "нуль нгултрумів, нуль четрумів"), (1.00, "один нгултрум, нуль четрумів"), (2.00, "два нгултруми, нуль четрумів"), (5.00, "п'ять нгултрумів, нуль четрумів"), (11.00, "одинадцять нгултрумів, нуль четрумів"), (16.01, "шістнадцять нгултрумів, один четрум"), (21.00, "двадцять один нгултрум, нуль четрумів"), (37.73, "тридцять сім нгултрумів, сімдесят три четруми"), (81.25, "вісімдесят один нгултрум, двадцять п'ять четрумів"), (100.00, "сто нгултрумів, нуль четрумів"), (101.11, "сто один нгултрум, одинадцять четрумів"), (10222, "сто два нгултруми, двадцять два четруми"), ) TEST_CASES_TO_CURRENCY_BWP = ( (0.00, "нуль пул, нуль тхебе"), (1.00, "одна пула, нуль тхебе"), (2.00, "дві пули, нуль тхебе"), (5.00, "п'ять пул, нуль тхебе"), (11.00, "одинадцять пул, нуль тхебе"), (16.01, "шістнадцять пул, один тхебе"), (21.00, "двадцять одна пула, нуль тхебе"), (37.73, "тридцять сім пул, сімдесят три тхебе"), (81.25, "вісімдесят одна пула, двадцять п'ять тхебе"), (100.00, "сто пул, нуль тхебе"), (101.11, "сто одна пула, одинадцять тхебе"), (10222, "сто дві пули, двадцять два тхебе"), ) TEST_CASES_TO_CURRENCY_BYN = ( (0.00, "нуль рублів, нуль копійок"), (1.00, "один рубель, нуль копійок"), (2.00, "два рублі, нуль копійок"), (5.00, "п'ять рублів, нуль копійок"), (11.00, "одинадцять рублів, нуль копійок"), (16.01, "шістнадцять рублів, одна копійка"), (21.00, "двадцять один рубель, нуль копійок"), (37.73, "тридцять сім рублів, сімдесят три копійки"), (81.25, "вісімдесят один рубель, двадцять п'ять копійок"), (100.00, "сто рублів, нуль копійок"), (101.11, "сто один рубель, одинадцять копійок"), (10222, "сто два рублі, двадцять дві копійки"), ) TEST_CASES_TO_CURRENCY_BZD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_CAD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_CDF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_CHF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_CLP = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_CNY = ( (0.00, "нуль юанів, нуль финів"), (1.00, "один юань, нуль финів"), (2.00, "два юані, нуль финів"), (5.00, "п'ять юанів, нуль финів"), (11.00, "одинадцять юанів, нуль финів"), (16.01, "шістнадцять юанів, один финь"), (21.00, "двадцять один юань, нуль финів"), (37.73, "тридцять сім юанів, сімдесят три фині"), (81.25, "вісімдесят один юань, двадцять п'ять финів"), (100.00, "сто юанів, нуль финів"), (101.11, "сто один юань, одинадцять финів"), (10222, "сто два юані, двадцять два фині"), ) TEST_CASES_TO_CURRENCY_COP = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_CRC = ( (0.00, "нуль колонів, нуль сентімо"), (1.00, "один колон, нуль сентімо"), (2.00, "два колони, нуль сентімо"), (5.00, "п'ять колонів, нуль сентімо"), (11.00, "одинадцять колонів, нуль сентімо"), (16.01, "шістнадцять колонів, один сентімо"), (21.00, "двадцять один колон, нуль сентімо"), (37.73, "тридцять сім колонів, сімдесят три сентімо"), (81.25, "вісімдесят один колон, двадцять п'ять сентімо"), (100.00, "сто колонів, нуль сентімо"), (101.11, "сто один колон, одинадцять сентімо"), (10222, "сто два колони, двадцять два сентімо"), ) TEST_CASES_TO_CURRENCY_CUC = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_CUP = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_CVE = ( (0.00, "нуль ескудо, нуль сентаво"), (1.00, "один ескудо, нуль сентаво"), (2.00, "два ескудо, нуль сентаво"), (5.00, "п'ять ескудо, нуль сентаво"), (11.00, "одинадцять ескудо, нуль сентаво"), (16.01, "шістнадцять ескудо, один сентаво"), (21.00, "двадцять один ескудо, нуль сентаво"), (37.73, "тридцять сім ескудо, сімдесят три сентаво"), (81.25, "вісімдесят один ескудо, двадцять п'ять сентаво"), (100.00, "сто ескудо, нуль сентаво"), (101.11, "сто один ескудо, одинадцять сентаво"), (10222, "сто два ескудо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_CZK = ( (0.00, "нуль крон, нуль гелерів"), (1.00, "одна крона, нуль гелерів"), (2.00, "дві крони, нуль гелерів"), (5.00, "п'ять крон, нуль гелерів"), (11.00, "одинадцять крон, нуль гелерів"), (16.01, "шістнадцять крон, один гелер"), (21.00, "двадцять одна крона, нуль гелерів"), (37.73, "тридцять сім крон, сімдесят три гелери"), (81.25, "вісімдесят одна крона, двадцять п'ять гелерів"), (100.00, "сто крон, нуль гелерів"), (101.11, "сто одна крона, одинадцять гелерів"), (10222, "сто дві крони, двадцять два гелери"), ) TEST_CASES_TO_CURRENCY_DJF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_DKK = ( (0.00, "нуль крон, нуль ере"), (1.00, "одна крона, нуль ере"), (2.00, "дві крони, нуль ере"), (5.00, "п'ять крон, нуль ере"), (11.00, "одинадцять крон, нуль ере"), (16.01, "шістнадцять крон, один ере"), (21.00, "двадцять одна крона, нуль ере"), (37.73, "тридцять сім крон, сімдесят три ере"), (81.25, "вісімдесят одна крона, двадцять п'ять ере"), (100.00, "сто крон, нуль ере"), (101.11, "сто одна крона, одинадцять ере"), (10222, "сто дві крони, двадцять два ере"), ) TEST_CASES_TO_CURRENCY_DOP = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_DZD = ( (0.00, "нуль динарів, нуль сантимів"), (1.00, "один динар, нуль сантимів"), (2.00, "два динари, нуль сантимів"), (5.00, "п'ять динарів, нуль сантимів"), (11.00, "одинадцять динарів, нуль сантимів"), (16.01, "шістнадцять динарів, один сантим"), (21.00, "двадцять один динар, нуль сантимів"), (37.73, "тридцять сім динарів, сімдесят три сантими"), (81.25, "вісімдесят один динар, двадцять п'ять сантимів"), (100.00, "сто динарів, нуль сантимів"), (101.11, "сто один динар, одинадцять сантимів"), (10222, "сто два динари, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_EGP = ( (0.00, "нуль фунтів, нуль піастрів"), (1.00, "один фунт, нуль піастрів"), (2.00, "два фунти, нуль піастрів"), (5.00, "п'ять фунтів, нуль піастрів"), (11.00, "одинадцять фунтів, нуль піастрів"), (16.01, "шістнадцять фунтів, один піастр"), (21.00, "двадцять один фунт, нуль піастрів"), (37.73, "тридцять сім фунтів, сімдесят три піастри"), (81.25, "вісімдесят один фунт, двадцять п'ять піастрів"), (100.00, "сто фунтів, нуль піастрів"), (101.11, "сто один фунт, одинадцять піастрів"), (10222, "сто два фунти, двадцять два піастри"), ) TEST_CASES_TO_CURRENCY_ERN = ( (0.00, "нуль накф, нуль центів"), (1.00, "одна накфа, нуль центів"), (2.00, "дві накфи, нуль центів"), (5.00, "п'ять накф, нуль центів"), (11.00, "одинадцять накф, нуль центів"), (16.01, "шістнадцять накф, один цент"), (21.00, "двадцять одна накфа, нуль центів"), (37.73, "тридцять сім накф, сімдесят три центи"), (81.25, "вісімдесят одна накфа, двадцять п'ять центів"), (100.00, "сто накф, нуль центів"), (101.11, "сто одна накфа, одинадцять центів"), (10222, "сто дві накфи, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_ETB = ( (0.00, "нуль бирів, нуль центів"), (1.00, "один бир, нуль центів"), (2.00, "два бири, нуль центів"), (5.00, "п'ять бирів, нуль центів"), (11.00, "одинадцять бирів, нуль центів"), (16.01, "шістнадцять бирів, один цент"), (21.00, "двадцять один бир, нуль центів"), (37.73, "тридцять сім бирів, сімдесят три центи"), (81.25, "вісімдесят один бир, двадцять п'ять центів"), (100.00, "сто бирів, нуль центів"), (101.11, "сто один бир, одинадцять центів"), (10222, "сто два бири, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_EUR = ( (0.00, "нуль євро, нуль центів"), (1.00, "один євро, нуль центів"), (2.00, "два євро, нуль центів"), (5.00, "п'ять євро, нуль центів"), (11.00, "одинадцять євро, нуль центів"), (16.01, "шістнадцять євро, один цент"), (21.00, "двадцять один євро, нуль центів"), (37.73, "тридцять сім євро, сімдесят три центи"), (81.25, "вісімдесят один євро, двадцять п'ять центів"), (100.00, "сто євро, нуль центів"), (101.11, "сто один євро, одинадцять центів"), (10222, "сто два євро, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_FJD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_FKP = ( (0.00, "нуль фунтів, нуль пенсів"), (1.00, "один фунт, нуль пенсів"), (2.00, "два фунти, нуль пенсів"), (5.00, "п'ять фунтів, нуль пенсів"), (11.00, "одинадцять фунтів, нуль пенсів"), (16.01, "шістнадцять фунтів, один пенс"), (21.00, "двадцять один фунт, нуль пенсів"), (37.73, "тридцять сім фунтів, сімдесят три пенси"), (81.25, "вісімдесят один фунт, двадцять п'ять пенсів"), (100.00, "сто фунтів, нуль пенсів"), (101.11, "сто один фунт, одинадцять пенсів"), (10222, "сто два фунти, двадцять два пенси"), ) TEST_CASES_TO_CURRENCY_GBP = ( (0.00, "нуль фунтів, нуль пенсів"), (1.00, "один фунт, нуль пенсів"), (2.00, "два фунти, нуль пенсів"), (5.00, "п'ять фунтів, нуль пенсів"), (11.00, "одинадцять фунтів, нуль пенсів"), (16.01, "шістнадцять фунтів, один пенс"), (21.00, "двадцять один фунт, нуль пенсів"), (37.73, "тридцять сім фунтів, сімдесят три пенси"), (81.25, "вісімдесят один фунт, двадцять п'ять пенсів"), (100.00, "сто фунтів, нуль пенсів"), (101.11, "сто один фунт, одинадцять пенсів"), (10222, "сто два фунти, двадцять два пенси"), ) TEST_CASES_TO_CURRENCY_GEL = ( (0.00, "нуль ларі, нуль тетрі"), (1.00, "один ларі, нуль тетрі"), (2.00, "два ларі, нуль тетрі"), (5.00, "п'ять ларі, нуль тетрі"), (11.00, "одинадцять ларі, нуль тетрі"), (16.01, "шістнадцять ларі, один тетрі"), (21.00, "двадцять один ларі, нуль тетрі"), (37.73, "тридцять сім ларі, сімдесят три тетрі"), (81.25, "вісімдесят один ларі, двадцять п'ять тетрі"), (100.00, "сто ларі, нуль тетрі"), (101.11, "сто один ларі, одинадцять тетрі"), (10222, "сто два ларі, двадцять два тетрі"), ) TEST_CASES_TO_CURRENCY_GHS = ( (0.00, "нуль седі, нуль песев"), (1.00, "один седі, нуль песев"), (2.00, "два седі, нуль песев"), (5.00, "п'ять седі, нуль песев"), (11.00, "одинадцять седі, нуль песев"), (16.01, "шістнадцять седі, одна песева"), (21.00, "двадцять один седі, нуль песев"), (37.73, "тридцять сім седі, сімдесят три песеви"), (81.25, "вісімдесят один седі, двадцять п'ять песев"), (100.00, "сто седі, нуль песев"), (101.11, "сто один седі, одинадцять песев"), (10222, "сто два седі, двадцять дві песеви"), ) TEST_CASES_TO_CURRENCY_GIP = ( (0.00, "нуль фунтів, нуль пенсів"), (1.00, "один фунт, нуль пенсів"), (2.00, "два фунти, нуль пенсів"), (5.00, "п'ять фунтів, нуль пенсів"), (11.00, "одинадцять фунтів, нуль пенсів"), (16.01, "шістнадцять фунтів, один пенс"), (21.00, "двадцять один фунт, нуль пенсів"), (37.73, "тридцять сім фунтів, сімдесят три пенси"), (81.25, "вісімдесят один фунт, двадцять п'ять пенсів"), (100.00, "сто фунтів, нуль пенсів"), (101.11, "сто один фунт, одинадцять пенсів"), (10222, "сто два фунти, двадцять два пенси"), ) TEST_CASES_TO_CURRENCY_GMD = ( (0.00, "нуль даласі, нуль бутутів"), (1.00, "один даласі, нуль бутутів"), (2.00, "два даласі, нуль бутутів"), (5.00, "п'ять даласі, нуль бутутів"), (11.00, "одинадцять даласі, нуль бутутів"), (16.01, "шістнадцять даласі, один бутут"), (21.00, "двадцять один даласі, нуль бутутів"), (37.73, "тридцять сім даласі, сімдесят три бутути"), (81.25, "вісімдесят один даласі, двадцять п'ять бутутів"), (100.00, "сто даласі, нуль бутутів"), (101.11, "сто один даласі, одинадцять бутутів"), (10222, "сто два даласі, двадцять два бутути"), ) TEST_CASES_TO_CURRENCY_GNF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_GTQ = ( (0.00, "нуль кетсалів, нуль сентаво"), (1.00, "один кетсаль, нуль сентаво"), (2.00, "два кетсалі, нуль сентаво"), (5.00, "п'ять кетсалів, нуль сентаво"), (11.00, "одинадцять кетсалів, нуль сентаво"), (16.01, "шістнадцять кетсалів, один сентаво"), (21.00, "двадцять один кетсаль, нуль сентаво"), (37.73, "тридцять сім кетсалів, сімдесят три сентаво"), (81.25, "вісімдесят один кетсаль, двадцять п'ять сентаво"), (100.00, "сто кетсалів, нуль сентаво"), (101.11, "сто один кетсаль, одинадцять сентаво"), (10222, "сто два кетсалі, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_GYD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_HKD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_HNL = ( (0.00, "нуль лемпір, нуль сентаво"), (1.00, "одна лемпіра, нуль сентаво"), (2.00, "дві лемпіри, нуль сентаво"), (5.00, "п'ять лемпір, нуль сентаво"), (11.00, "одинадцять лемпір, нуль сентаво"), (16.01, "шістнадцять лемпір, один сентаво"), (21.00, "двадцять одна лемпіра, нуль сентаво"), (37.73, "тридцять сім лемпір, сімдесят три сентаво"), (81.25, "вісімдесят одна лемпіра, двадцять п'ять сентаво"), (100.00, "сто лемпір, нуль сентаво"), (101.11, "сто одна лемпіра, одинадцять сентаво"), (10222, "сто дві лемпіри, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_HRK = ( (0.00, "нуль кун, нуль ліп"), (1.00, "одна куна, нуль ліп"), (2.00, "дві куни, нуль ліп"), (5.00, "п'ять кун, нуль ліп"), (11.00, "одинадцять кун, нуль ліп"), (16.01, "шістнадцять кун, одна ліпа"), (21.00, "двадцять одна куна, нуль ліп"), (37.73, "тридцять сім кун, сімдесят три ліпи"), (81.25, "вісімдесят одна куна, двадцять п'ять ліп"), (100.00, "сто кун, нуль ліп"), (101.11, "сто одна куна, одинадцять ліп"), (10222, "сто дві куни, двадцять дві ліпи"), ) TEST_CASES_TO_CURRENCY_HTG = ( (0.00, "нуль гурдів, нуль сантимів"), (1.00, "один гурд, нуль сантимів"), (2.00, "два гурди, нуль сантимів"), (5.00, "п'ять гурдів, нуль сантимів"), (11.00, "одинадцять гурдів, нуль сантимів"), (16.01, "шістнадцять гурдів, один сантим"), (21.00, "двадцять один гурд, нуль сантимів"), (37.73, "тридцять сім гурдів, сімдесят три сантими"), (81.25, "вісімдесят один гурд, двадцять п'ять сантимів"), (100.00, "сто гурдів, нуль сантимів"), (101.11, "сто один гурд, одинадцять сантимів"), (10222, "сто два гурди, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_HUF = ( (0.00, "нуль форинтів, нуль філлерів"), (1.00, "один форинт, нуль філлерів"), (2.00, "два форинти, нуль філлерів"), (5.00, "п'ять форинтів, нуль філлерів"), (11.00, "одинадцять форинтів, нуль філлерів"), (16.01, "шістнадцять форинтів, один філлер"), (21.00, "двадцять один форинт, нуль філлерів"), (37.73, "тридцять сім форинтів, сімдесят три філлери"), (81.25, "вісімдесят один форинт, двадцять п'ять філлерів"), (100.00, "сто форинтів, нуль філлерів"), (101.11, "сто один форинт, одинадцять філлерів"), (10222, "сто два форинти, двадцять два філлери"), ) TEST_CASES_TO_CURRENCY_IDR = ( (0.00, "нуль рупій, нуль центів"), (1.00, "одна рупія, нуль центів"), (2.00, "дві рупії, нуль центів"), (5.00, "п'ять рупій, нуль центів"), (11.00, "одинадцять рупій, нуль центів"), (16.01, "шістнадцять рупій, один цент"), (21.00, "двадцять одна рупія, нуль центів"), (37.73, "тридцять сім рупій, сімдесят три центи"), (81.25, "вісімдесят одна рупія, двадцять п'ять центів"), (100.00, "сто рупій, нуль центів"), (101.11, "сто одна рупія, одинадцять центів"), (10222, "сто дві рупії, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_ILS = ( (0.00, "нуль шекелів, нуль агор"), (1.00, "один шекель, нуль агор"), (2.00, "два шекелі, нуль агор"), (5.00, "п'ять шекелів, нуль агор"), (11.00, "одинадцять шекелів, нуль агор"), (16.01, "шістнадцять шекелів, одна агора"), (21.00, "двадцять один шекель, нуль агор"), (37.73, "тридцять сім шекелів, сімдесят три агори"), (81.25, "вісімдесят один шекель, двадцять п'ять агор"), (100.00, "сто шекелів, нуль агор"), (101.11, "сто один шекель, одинадцять агор"), (10222, "сто два шекелі, двадцять дві агори"), ) TEST_CASES_TO_CURRENCY_INR = ( (0.00, "нуль рупій, нуль пайс"), (1.00, "одна рупія, нуль пайс"), (2.00, "дві рупії, нуль пайс"), (5.00, "п'ять рупій, нуль пайс"), (11.00, "одинадцять рупій, нуль пайс"), (16.01, "шістнадцять рупій, одна пайса"), (21.00, "двадцять одна рупія, нуль пайс"), (37.73, "тридцять сім рупій, сімдесят три пайси"), (81.25, "вісімдесят одна рупія, двадцять п'ять пайс"), (100.00, "сто рупій, нуль пайс"), (101.11, "сто одна рупія, одинадцять пайс"), (10222, "сто дві рупії, двадцять дві пайси"), ) TEST_CASES_TO_CURRENCY_IQD = ( (0.00, "нуль динарів, нуль філсів"), (1.00, "один динар, нуль філсів"), (2.00, "два динари, нуль філсів"), (5.00, "п'ять динарів, нуль філсів"), (11.00, "одинадцять динарів, нуль філсів"), (16.01, "шістнадцять динарів, один філс"), (21.00, "двадцять один динар, нуль філсів"), (37.73, "тридцять сім динарів, сімдесят три філси"), (81.25, "вісімдесят один динар, двадцять п'ять філсів"), (100.00, "сто динарів, нуль філсів"), (101.11, "сто один динар, одинадцять філсів"), (10222, "сто два динари, двадцять два філси"), ) TEST_CASES_TO_CURRENCY_IRR = ( (0.00, "нуль ріалів, нуль динарів"), (1.00, "один ріал, нуль динарів"), (2.00, "два ріали, нуль динарів"), (5.00, "п'ять ріалів, нуль динарів"), (11.00, "одинадцять ріалів, нуль динарів"), (16.01, "шістнадцять ріалів, один динар"), (21.00, "двадцять один ріал, нуль динарів"), (37.73, "тридцять сім ріалів, сімдесят три динари"), (81.25, "вісімдесят один ріал, двадцять п'ять динарів"), (100.00, "сто ріалів, нуль динарів"), (101.11, "сто один ріал, одинадцять динарів"), (10222, "сто два ріали, двадцять два динари"), ) TEST_CASES_TO_CURRENCY_ISK = ( (0.00, "нуль крон, нуль ейре"), (1.00, "одна крона, нуль ейре"), (2.00, "дві крони, нуль ейре"), (5.00, "п'ять крон, нуль ейре"), (11.00, "одинадцять крон, нуль ейре"), (16.01, "шістнадцять крон, один ейре"), (21.00, "двадцять одна крона, нуль ейре"), (37.73, "тридцять сім крон, сімдесят три ейре"), (81.25, "вісімдесят одна крона, двадцять п'ять ейре"), (100.00, "сто крон, нуль ейре"), (101.11, "сто одна крона, одинадцять ейре"), (10222, "сто дві крони, двадцять два ейре"), ) TEST_CASES_TO_CURRENCY_JMD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_JOD = ( (0.00, "нуль динарів, нуль філсів"), (1.00, "один динар, нуль філсів"), (2.00, "два динари, нуль філсів"), (5.00, "п'ять динарів, нуль філсів"), (11.00, "одинадцять динарів, нуль філсів"), (16.01, "шістнадцять динарів, один філс"), (21.00, "двадцять один динар, нуль філсів"), (37.73, "тридцять сім динарів, сімдесят три філси"), (81.25, "вісімдесят один динар, двадцять п'ять філсів"), (100.00, "сто динарів, нуль філсів"), (101.11, "сто один динар, одинадцять філсів"), (10222, "сто два динари, двадцять два філси"), ) TEST_CASES_TO_CURRENCY_JPY = ( (0.00, "нуль єн, нуль сен"), (1.00, "одна єна, нуль сен"), (2.00, "дві єни, нуль сен"), (5.00, "п'ять єн, нуль сен"), (11.00, "одинадцять єн, нуль сен"), (16.01, "шістнадцять єн, один сен"), (21.00, "двадцять одна єна, нуль сен"), (37.73, "тридцять сім єн, сімдесят три сен"), (81.25, "вісімдесят одна єна, двадцять п'ять сен"), (100.00, "сто єн, нуль сен"), (101.11, "сто одна єна, одинадцять сен"), (10222, "сто дві єни, двадцять два сен"), ) TEST_CASES_TO_CURRENCY_KES = ( (0.00, "нуль шилінгів, нуль центів"), (1.00, "один шилінг, нуль центів"), (2.00, "два шилінги, нуль центів"), (5.00, "п'ять шилінгів, нуль центів"), (11.00, "одинадцять шилінгів, нуль центів"), (16.01, "шістнадцять шилінгів, один цент"), (21.00, "двадцять один шилінг, нуль центів"), (37.73, "тридцять сім шилінгів, сімдесят три центи"), (81.25, "вісімдесят один шилінг, двадцять п'ять центів"), (100.00, "сто шилінгів, нуль центів"), (101.11, "сто один шилінг, одинадцять центів"), (10222, "сто два шилінги, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_KGS = ( (0.00, "нуль сомів, нуль тиїнів"), (1.00, "один сом, нуль тиїнів"), (2.00, "два соми, нуль тиїнів"), (5.00, "п'ять сомів, нуль тиїнів"), (11.00, "одинадцять сомів, нуль тиїнів"), (16.01, "шістнадцять сомів, один тиїн"), (21.00, "двадцять один сом, нуль тиїнів"), (37.73, "тридцять сім сомів, сімдесят три тиїни"), (81.25, "вісімдесят один сом, двадцять п'ять тиїнів"), (100.00, "сто сомів, нуль тиїнів"), (101.11, "сто один сом, одинадцять тиїнів"), (10222, "сто два соми, двадцять два тиїни"), ) TEST_CASES_TO_CURRENCY_KHR = ( (0.00, "нуль рієлів, нуль су"), (1.00, "один рієль, нуль су"), (2.00, "два рієлі, нуль су"), (5.00, "п'ять рієлів, нуль су"), (11.00, "одинадцять рієлів, нуль су"), (16.01, "шістнадцять рієлів, один су"), (21.00, "двадцять один рієль, нуль су"), (37.73, "тридцять сім рієлів, сімдесят три су"), (81.25, "вісімдесят один рієль, двадцять п'ять су"), (100.00, "сто рієлів, нуль су"), (101.11, "сто один рієль, одинадцять су"), (10222, "сто два рієлі, двадцять два су"), ) TEST_CASES_TO_CURRENCY_KMF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_KPW = ( (0.00, "нуль вон, нуль чонів"), (1.00, "одна вона, нуль чонів"), (2.00, "дві вони, нуль чонів"), (5.00, "п'ять вон, нуль чонів"), (11.00, "одинадцять вон, нуль чонів"), (16.01, "шістнадцять вон, один чон"), (21.00, "двадцять одна вона, нуль чонів"), (37.73, "тридцять сім вон, сімдесят три чони"), (81.25, "вісімдесят одна вона, двадцять п'ять чонів"), (100.00, "сто вон, нуль чонів"), (101.11, "сто одна вона, одинадцять чонів"), (10222, "сто дві вони, двадцять два чони"), ) TEST_CASES_TO_CURRENCY_KRW = ( (0.00, "нуль вон, нуль джеонів"), (1.00, "одна вона, нуль джеонів"), (2.00, "дві вони, нуль джеонів"), (5.00, "п'ять вон, нуль джеонів"), (11.00, "одинадцять вон, нуль джеонів"), (16.01, "шістнадцять вон, один джеон"), (21.00, "двадцять одна вона, нуль джеонів"), (37.73, "тридцять сім вон, сімдесят три джеони"), (81.25, "вісімдесят одна вона, двадцять п'ять джеонів"), (100.00, "сто вон, нуль джеонів"), (101.11, "сто одна вона, одинадцять джеонів"), (10222, "сто дві вони, двадцять два джеони"), ) TEST_CASES_TO_CURRENCY_KWD = ( (0.00, "нуль динарів, нуль філсів"), (1.00, "один динар, нуль філсів"), (2.00, "два динари, нуль філсів"), (5.00, "п'ять динарів, нуль філсів"), (11.00, "одинадцять динарів, нуль філсів"), (16.01, "шістнадцять динарів, один філс"), (21.00, "двадцять один динар, нуль філсів"), (37.73, "тридцять сім динарів, сімдесят три філси"), (81.25, "вісімдесят один динар, двадцять п'ять філсів"), (100.00, "сто динарів, нуль філсів"), (101.11, "сто один динар, одинадцять філсів"), (10222, "сто два динари, двадцять два філси"), ) TEST_CASES_TO_CURRENCY_KYD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_KZT = ( (0.00, "нуль теньге, нуль тиїнів"), (1.00, "один теньге, нуль тиїнів"), (2.00, "два теньге, нуль тиїнів"), (5.00, "п'ять теньге, нуль тиїнів"), (11.00, "одинадцять теньге, нуль тиїнів"), (16.01, "шістнадцять теньге, один тиїн"), (21.00, "двадцять один теньге, нуль тиїнів"), (37.73, "тридцять сім теньге, сімдесят три тиїни"), (81.25, "вісімдесят один теньге, двадцять п'ять тиїнів"), (100.00, "сто теньге, нуль тиїнів"), (101.11, "сто один теньге, одинадцять тиїнів"), (10222, "сто два теньге, двадцять два тиїни"), ) TEST_CASES_TO_CURRENCY_LAK = ( (0.00, "нуль кіпів, нуль атів"), (1.00, "один кіп, нуль атів"), (2.00, "два кіпи, нуль атів"), (5.00, "п'ять кіпів, нуль атів"), (11.00, "одинадцять кіпів, нуль атів"), (16.01, "шістнадцять кіпів, один ат"), (21.00, "двадцять один кіп, нуль атів"), (37.73, "тридцять сім кіпів, сімдесят три ати"), (81.25, "вісімдесят один кіп, двадцять п'ять атів"), (100.00, "сто кіпів, нуль атів"), (101.11, "сто один кіп, одинадцять атів"), (10222, "сто два кіпи, двадцять два ати"), ) TEST_CASES_TO_CURRENCY_LBP = ( (0.00, "нуль фунтів, нуль піастрів"), (1.00, "один фунт, нуль піастрів"), (2.00, "два фунти, нуль піастрів"), (5.00, "п'ять фунтів, нуль піастрів"), (11.00, "одинадцять фунтів, нуль піастрів"), (16.01, "шістнадцять фунтів, один піастр"), (21.00, "двадцять один фунт, нуль піастрів"), (37.73, "тридцять сім фунтів, сімдесят три піастри"), (81.25, "вісімдесят один фунт, двадцять п'ять піастрів"), (100.00, "сто фунтів, нуль піастрів"), (101.11, "сто один фунт, одинадцять піастрів"), (10222, "сто два фунти, двадцять два піастри"), ) TEST_CASES_TO_CURRENCY_LKR = ( (0.00, "нуль рупій, нуль центів"), (1.00, "одна рупія, нуль центів"), (2.00, "дві рупії, нуль центів"), (5.00, "п'ять рупій, нуль центів"), (11.00, "одинадцять рупій, нуль центів"), (16.01, "шістнадцять рупій, один цент"), (21.00, "двадцять одна рупія, нуль центів"), (37.73, "тридцять сім рупій, сімдесят три центи"), (81.25, "вісімдесят одна рупія, двадцять п'ять центів"), (100.00, "сто рупій, нуль центів"), (101.11, "сто одна рупія, одинадцять центів"), (10222, "сто дві рупії, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_LRD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_LSL = ( (0.00, "нуль малоті, нуль лісенте"), (1.00, "один лоті, нуль лісенте"), (2.00, "два малоті, нуль лісенте"), (5.00, "п'ять малоті, нуль лісенте"), (11.00, "одинадцять малоті, нуль лісенте"), (16.01, "шістнадцять малоті, один сенте"), (21.00, "двадцять один лоті, нуль лісенте"), (37.73, "тридцять сім малоті, сімдесят три лісенте"), (81.25, "вісімдесят один лоті, двадцять п'ять лісенте"), (100.00, "сто малоті, нуль лісенте"), (101.11, "сто один лоті, одинадцять лісенте"), (10222, "сто два малоті, двадцять два лісенте"), ) TEST_CASES_TO_CURRENCY_LYD = ( (0.00, "нуль динарів, нуль дирхамів"), (1.00, "один динар, нуль дирхамів"), (2.00, "два динари, нуль дирхамів"), (5.00, "п'ять динарів, нуль дирхамів"), (11.00, "одинадцять динарів, нуль дирхамів"), (16.01, "шістнадцять динарів, один дирхам"), (21.00, "двадцять один динар, нуль дирхамів"), (37.73, "тридцять сім динарів, сімдесят три дирхами"), (81.25, "вісімдесят один динар, двадцять п'ять дирхамів"), (100.00, "сто динарів, нуль дирхамів"), (101.11, "сто один динар, одинадцять дирхамів"), (10222, "сто два динари, двадцять два дирхами"), ) TEST_CASES_TO_CURRENCY_MAD = ( (0.00, "нуль дирхамів, нуль сантимів"), (1.00, "один дирхам, нуль сантимів"), (2.00, "два дирхами, нуль сантимів"), (5.00, "п'ять дирхамів, нуль сантимів"), (11.00, "одинадцять дирхамів, нуль сантимів"), (16.01, "шістнадцять дирхамів, один сантим"), (21.00, "двадцять один дирхам, нуль сантимів"), (37.73, "тридцять сім дирхамів, сімдесят три сантими"), (81.25, "вісімдесят один дирхам, двадцять п'ять сантимів"), (100.00, "сто дирхамів, нуль сантимів"), (101.11, "сто один дирхам, одинадцять сантимів"), (10222, "сто два дирхами, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_MDL = ( (0.00, "нуль леї, нуль бані"), (1.00, "один лей, нуль бані"), (2.00, "два леї, нуль бані"), (5.00, "п'ять леї, нуль бані"), (11.00, "одинадцять леї, нуль бані"), (16.01, "шістнадцять леї, один бан"), (21.00, "двадцять один лей, нуль бані"), (37.73, "тридцять сім леї, сімдесят три бані"), (81.25, "вісімдесят один лей, двадцять п'ять бані"), (100.00, "сто леї, нуль бані"), (101.11, "сто один лей, одинадцять бані"), (10222, "сто два леї, двадцять два бані"), ) TEST_CASES_TO_CURRENCY_MGA = ( (0.00, "нуль аріарі, нуль іраймбіланья"), (1.00, "один аріарі, нуль іраймбіланья"), (2.00, "два аріарі, нуль іраймбіланья"), (5.00, "п'ять аріарі, нуль іраймбіланья"), (11.00, "одинадцять аріарі, нуль іраймбіланья"), (16.01, "шістнадцять аріарі, один іраймбіланья"), (21.00, "двадцять один аріарі, нуль іраймбіланья"), (37.73, "тридцять сім аріарі, сімдесят три іраймбіланья"), (81.25, "вісімдесят один аріарі, двадцять п'ять іраймбіланья"), (100.00, "сто аріарі, нуль іраймбіланья"), (101.11, "сто один аріарі, одинадцять іраймбіланья"), (10222, "сто два аріарі, двадцять два іраймбіланья"), ) TEST_CASES_TO_CURRENCY_MKD = ( (0.00, "нуль денарів, нуль дені"), (1.00, "один денар, нуль дені"), (2.00, "два денари, нуль дені"), (5.00, "п'ять денарів, нуль дені"), (11.00, "одинадцять денарів, нуль дені"), (16.01, "шістнадцять денарів, один дені"), (21.00, "двадцять один денар, нуль дені"), (37.73, "тридцять сім денарів, сімдесят три дені"), (81.25, "вісімдесят один денар, двадцять п'ять дені"), (100.00, "сто денарів, нуль дені"), (101.11, "сто один денар, одинадцять дені"), (10222, "сто два денари, двадцять два дені"), ) TEST_CASES_TO_CURRENCY_MMK = ( (0.00, "нуль к'ят, нуль п'я"), (1.00, "один к'ят, нуль п'я"), (2.00, "два к'ят, нуль п'я"), (5.00, "п'ять к'ят, нуль п'я"), (11.00, "одинадцять к'ят, нуль п'я"), (16.01, "шістнадцять к'ят, один п'я"), (21.00, "двадцять один к'ят, нуль п'я"), (37.73, "тридцять сім к'ят, сімдесят три п'я"), (81.25, "вісімдесят один к'ят, двадцять п'ять п'я"), (100.00, "сто к'ят, нуль п'я"), (101.11, "сто один к'ят, одинадцять п'я"), (10222, "сто два к'ят, двадцять два п'я"), ) TEST_CASES_TO_CURRENCY_MNT = ( (0.00, "нуль тугриків, нуль мунгу"), (1.00, "один тугрик, нуль мунгу"), (2.00, "два тугрики, нуль мунгу"), (5.00, "п'ять тугриків, нуль мунгу"), (11.00, "одинадцять тугриків, нуль мунгу"), (16.01, "шістнадцять тугриків, один мунгу"), (21.00, "двадцять один тугрик, нуль мунгу"), (37.73, "тридцять сім тугриків, сімдесят три мунгу"), (81.25, "вісімдесят один тугрик, двадцять п'ять мунгу"), (100.00, "сто тугриків, нуль мунгу"), (101.11, "сто один тугрик, одинадцять мунгу"), (10222, "сто два тугрики, двадцять два мунгу"), ) TEST_CASES_TO_CURRENCY_MOP = ( (0.00, "нуль патак, нуль аво"), (1.00, "одна патака, нуль аво"), (2.00, "дві патакі, нуль аво"), (5.00, "п'ять патак, нуль аво"), (11.00, "одинадцять патак, нуль аво"), (16.01, "шістнадцять патак, один аво"), (21.00, "двадцять одна патака, нуль аво"), (37.73, "тридцять сім патак, сімдесят три аво"), (81.25, "вісімдесят одна патака, двадцять п'ять аво"), (100.00, "сто патак, нуль аво"), (101.11, "сто одна патака, одинадцять аво"), (10222, "сто дві патакі, двадцять два аво"), ) TEST_CASES_TO_CURRENCY_MRU = ( (0.00, "нуль угій, нуль хумс"), (1.00, "одна угія, нуль хумс"), (2.00, "дві угії, нуль хумс"), (5.00, "п'ять угій, нуль хумс"), (11.00, "одинадцять угій, нуль хумс"), (16.01, "шістнадцять угій, один хумс"), (21.00, "двадцять одна угія, нуль хумс"), (37.73, "тридцять сім угій, сімдесят три хумс"), (81.25, "вісімдесят одна угія, двадцять п'ять хумс"), (100.00, "сто угій, нуль хумс"), (101.11, "сто одна угія, одинадцять хумс"), (10222, "сто дві угії, двадцять два хумс"), ) TEST_CASES_TO_CURRENCY_MUR = ( (0.00, "нуль рупій, нуль центів"), (1.00, "одна рупія, нуль центів"), (2.00, "дві рупії, нуль центів"), (5.00, "п'ять рупій, нуль центів"), (11.00, "одинадцять рупій, нуль центів"), (16.01, "шістнадцять рупій, один цент"), (21.00, "двадцять одна рупія, нуль центів"), (37.73, "тридцять сім рупій, сімдесят три центи"), (81.25, "вісімдесят одна рупія, двадцять п'ять центів"), (100.00, "сто рупій, нуль центів"), (101.11, "сто одна рупія, одинадцять центів"), (10222, "сто дві рупії, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_MVR = ( (0.00, "нуль руфій, нуль ларі"), (1.00, "одна руфія, нуль ларі"), (2.00, "дві руфії, нуль ларі"), (5.00, "п'ять руфій, нуль ларі"), (11.00, "одинадцять руфій, нуль ларі"), (16.01, "шістнадцять руфій, один ларі"), (21.00, "двадцять одна руфія, нуль ларі"), (37.73, "тридцять сім руфій, сімдесят три ларі"), (81.25, "вісімдесят одна руфія, двадцять п'ять ларі"), (100.00, "сто руфій, нуль ларі"), (101.11, "сто одна руфія, одинадцять ларі"), (10222, "сто дві руфії, двадцять два ларі"), ) TEST_CASES_TO_CURRENCY_MWK = ( (0.00, "нуль квач, нуль тамбала"), (1.00, "одна квача, нуль тамбала"), (2.00, "дві квачі, нуль тамбала"), (5.00, "п'ять квач, нуль тамбала"), (11.00, "одинадцять квач, нуль тамбала"), (16.01, "шістнадцять квач, один тамбала"), (21.00, "двадцять одна квача, нуль тамбала"), (37.73, "тридцять сім квач, сімдесят три тамбала"), (81.25, "вісімдесят одна квача, двадцять п'ять тамбала"), (100.00, "сто квач, нуль тамбала"), (101.11, "сто одна квача, одинадцять тамбала"), (10222, "сто дві квачі, двадцять два тамбала"), ) TEST_CASES_TO_CURRENCY_MXN = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_MYR = ( (0.00, "нуль рингітів, нуль центів"), (1.00, "один рингіт, нуль центів"), (2.00, "два рингіти, нуль центів"), (5.00, "п'ять рингітів, нуль центів"), (11.00, "одинадцять рингітів, нуль центів"), (16.01, "шістнадцять рингітів, один цент"), (21.00, "двадцять один рингіт, нуль центів"), (37.73, "тридцять сім рингітів, сімдесят три центи"), (81.25, "вісімдесят один рингіт, двадцять п'ять центів"), (100.00, "сто рингітів, нуль центів"), (101.11, "сто один рингіт, одинадцять центів"), (10222, "сто два рингіти, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_MZN = ( (0.00, "нуль метікалів, нуль сентаво"), (1.00, "один метікал, нуль сентаво"), (2.00, "два метікали, нуль сентаво"), (5.00, "п'ять метікалів, нуль сентаво"), (11.00, "одинадцять метікалів, нуль сентаво"), (16.01, "шістнадцять метікалів, один сентаво"), (21.00, "двадцять один метікал, нуль сентаво"), (37.73, "тридцять сім метікалів, сімдесят три сентаво"), (81.25, "вісімдесят один метікал, двадцять п'ять сентаво"), (100.00, "сто метікалів, нуль сентаво"), (101.11, "сто один метікал, одинадцять сентаво"), (10222, "сто два метікали, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_NAD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_NGN = ( (0.00, "нуль найр, нуль кобо"), (1.00, "одна найра, нуль кобо"), (2.00, "дві найри, нуль кобо"), (5.00, "п'ять найр, нуль кобо"), (11.00, "одинадцять найр, нуль кобо"), (16.01, "шістнадцять найр, один кобо"), (21.00, "двадцять одна найра, нуль кобо"), (37.73, "тридцять сім найр, сімдесят три кобо"), (81.25, "вісімдесят одна найра, двадцять п'ять кобо"), (100.00, "сто найр, нуль кобо"), (101.11, "сто одна найра, одинадцять кобо"), (10222, "сто дві найри, двадцять два кобо"), ) TEST_CASES_TO_CURRENCY_NIO = ( (0.00, "нуль кордоб, нуль сентаво"), (1.00, "одна кордоба, нуль сентаво"), (2.00, "дві кордоби, нуль сентаво"), (5.00, "п'ять кордоб, нуль сентаво"), (11.00, "одинадцять кордоб, нуль сентаво"), (16.01, "шістнадцять кордоб, один сентаво"), (21.00, "двадцять одна кордоба, нуль сентаво"), (37.73, "тридцять сім кордоб, сімдесят три сентаво"), (81.25, "вісімдесят одна кордоба, двадцять п'ять сентаво"), (100.00, "сто кордоб, нуль сентаво"), (101.11, "сто одна кордоба, одинадцять сентаво"), (10222, "сто дві кордоби, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_NOK = ( (0.00, "нуль крон, нуль ере"), (1.00, "одна крона, нуль ере"), (2.00, "дві крони, нуль ере"), (5.00, "п'ять крон, нуль ере"), (11.00, "одинадцять крон, нуль ере"), (16.01, "шістнадцять крон, один ере"), (21.00, "двадцять одна крона, нуль ере"), (37.73, "тридцять сім крон, сімдесят три ере"), (81.25, "вісімдесят одна крона, двадцять п'ять ере"), (100.00, "сто крон, нуль ере"), (101.11, "сто одна крона, одинадцять ере"), (10222, "сто дві крони, двадцять два ере"), ) TEST_CASES_TO_CURRENCY_NPR = ( (0.00, "нуль рупій, нуль пайс"), (1.00, "одна рупія, нуль пайс"), (2.00, "дві рупії, нуль пайс"), (5.00, "п'ять рупій, нуль пайс"), (11.00, "одинадцять рупій, нуль пайс"), (16.01, "шістнадцять рупій, одна пайса"), (21.00, "двадцять одна рупія, нуль пайс"), (37.73, "тридцять сім рупій, сімдесят три пайси"), (81.25, "вісімдесят одна рупія, двадцять п'ять пайс"), (100.00, "сто рупій, нуль пайс"), (101.11, "сто одна рупія, одинадцять пайс"), (10222, "сто дві рупії, двадцять дві пайси"), ) TEST_CASES_TO_CURRENCY_NZD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_OMR = ( (0.00, "нуль ріалів, нуль байз"), (1.00, "один ріал, нуль байз"), (2.00, "два ріали, нуль байз"), (5.00, "п'ять ріалів, нуль байз"), (11.00, "одинадцять ріалів, нуль байз"), (16.01, "шістнадцять ріалів, одна байза"), (21.00, "двадцять один ріал, нуль байз"), (37.73, "тридцять сім ріалів, сімдесят три байзи"), (81.25, "вісімдесят один ріал, двадцять п'ять байз"), (100.00, "сто ріалів, нуль байз"), (101.11, "сто один ріал, одинадцять байз"), (10222, "сто два ріали, двадцять дві байзи"), ) TEST_CASES_TO_CURRENCY_PAB = ( (0.00, "нуль бальбоа, нуль сентесімо"), (1.00, "один бальбоа, нуль сентесімо"), (2.00, "два бальбоа, нуль сентесімо"), (5.00, "п'ять бальбоа, нуль сентесімо"), (11.00, "одинадцять бальбоа, нуль сентесімо"), (16.01, "шістнадцять бальбоа, один сентесімо"), (21.00, "двадцять один бальбоа, нуль сентесімо"), (37.73, "тридцять сім бальбоа, сімдесят три сентесімо"), (81.25, "вісімдесят один бальбоа, двадцять п'ять сентесімо"), (100.00, "сто бальбоа, нуль сентесімо"), (101.11, "сто один бальбоа, одинадцять сентесімо"), (10222, "сто два бальбоа, двадцять два сентесімо"), ) TEST_CASES_TO_CURRENCY_PEN = ( (0.00, "нуль соль, нуль сентімо"), (1.00, "один соль, нуль сентімо"), (2.00, "два соль, нуль сентімо"), (5.00, "п'ять соль, нуль сентімо"), (11.00, "одинадцять соль, нуль сентімо"), (16.01, "шістнадцять соль, один сентімо"), (21.00, "двадцять один соль, нуль сентімо"), (37.73, "тридцять сім соль, сімдесят три сентімо"), (81.25, "вісімдесят один соль, двадцять п'ять сентімо"), (100.00, "сто соль, нуль сентімо"), (101.11, "сто один соль, одинадцять сентімо"), (10222, "сто два соль, двадцять два сентімо"), ) TEST_CASES_TO_CURRENCY_PGK = ( (0.00, "нуль кіна, нуль тойя"), (1.00, "один кіна, нуль тойя"), (2.00, "два кіна, нуль тойя"), (5.00, "п'ять кіна, нуль тойя"), (11.00, "одинадцять кіна, нуль тойя"), (16.01, "шістнадцять кіна, один тойя"), (21.00, "двадцять один кіна, нуль тойя"), (37.73, "тридцять сім кіна, сімдесят три тойя"), (81.25, "вісімдесят один кіна, двадцять п'ять тойя"), (100.00, "сто кіна, нуль тойя"), (101.11, "сто один кіна, одинадцять тойя"), (10222, "сто два кіна, двадцять два тойя"), ) TEST_CASES_TO_CURRENCY_PHP = ( (0.00, "нуль песо, нуль сентаво"), (1.00, "один песо, нуль сентаво"), (2.00, "два песо, нуль сентаво"), (5.00, "п'ять песо, нуль сентаво"), (11.00, "одинадцять песо, нуль сентаво"), (16.01, "шістнадцять песо, один сентаво"), (21.00, "двадцять один песо, нуль сентаво"), (37.73, "тридцять сім песо, сімдесят три сентаво"), (81.25, "вісімдесят один песо, двадцять п'ять сентаво"), (100.00, "сто песо, нуль сентаво"), (101.11, "сто один песо, одинадцять сентаво"), (10222, "сто два песо, двадцять два сентаво"), ) TEST_CASES_TO_CURRENCY_PKR = ( (0.00, "нуль рупій, нуль пайс"), (1.00, "одна рупія, нуль пайс"), (2.00, "дві рупії, нуль пайс"), (5.00, "п'ять рупій, нуль пайс"), (11.00, "одинадцять рупій, нуль пайс"), (16.01, "шістнадцять рупій, одна пайса"), (21.00, "двадцять одна рупія, нуль пайс"), (37.73, "тридцять сім рупій, сімдесят три пайси"), (81.25, "вісімдесят одна рупія, двадцять п'ять пайс"), (100.00, "сто рупій, нуль пайс"), (101.11, "сто одна рупія, одинадцять пайс"), (10222, "сто дві рупії, двадцять дві пайси"), ) TEST_CASES_TO_CURRENCY_PLN = ( (0.00, "нуль злотих, нуль грошів"), (1.00, "один злотий, нуль грошів"), (2.00, "два злоті, нуль грошів"), (5.00, "п'ять злотих, нуль грошів"), (11.00, "одинадцять злотих, нуль грошів"), (16.01, "шістнадцять злотих, один грош"), (21.00, "двадцять один злотий, нуль грошів"), (37.73, "тридцять сім злотих, сімдесят три гроші"), (81.25, "вісімдесят один злотий, двадцять п'ять грошів"), (100.00, "сто злотих, нуль грошів"), (101.11, "сто один злотий, одинадцять грошів"), (10222, "сто два злоті, двадцять два гроші"), ) TEST_CASES_TO_CURRENCY_PYG = ( (0.00, "нуль гуарані, нуль сентімо"), (1.00, "один гуарані, нуль сентімо"), (2.00, "два гуарані, нуль сентімо"), (5.00, "п'ять гуарані, нуль сентімо"), (11.00, "одинадцять гуарані, нуль сентімо"), (16.01, "шістнадцять гуарані, один сентімо"), (21.00, "двадцять один гуарані, нуль сентімо"), (37.73, "тридцять сім гуарані, сімдесят три сентімо"), (81.25, "вісімдесят один гуарані, двадцять п'ять сентімо"), (100.00, "сто гуарані, нуль сентімо"), (101.11, "сто один гуарані, одинадцять сентімо"), (10222, "сто два гуарані, двадцять два сентімо"), ) TEST_CASES_TO_CURRENCY_QAR = ( (0.00, "нуль ріалів, нуль дирхамів"), (1.00, "один ріал, нуль дирхамів"), (2.00, "два ріали, нуль дирхамів"), (5.00, "п'ять ріалів, нуль дирхамів"), (11.00, "одинадцять ріалів, нуль дирхамів"), (16.01, "шістнадцять ріалів, один дирхам"), (21.00, "двадцять один ріал, нуль дирхамів"), (37.73, "тридцять сім ріалів, сімдесят три дирхами"), (81.25, "вісімдесят один ріал, двадцять п'ять дирхамів"), (100.00, "сто ріалів, нуль дирхамів"), (101.11, "сто один ріал, одинадцять дирхамів"), (10222, "сто два ріали, двадцять два дирхами"), ) TEST_CASES_TO_CURRENCY_RON = ( (0.00, "нуль леї, нуль бані"), (1.00, "один лей, нуль бані"), (2.00, "два леї, нуль бані"), (5.00, "п'ять леї, нуль бані"), (11.00, "одинадцять леї, нуль бані"), (16.01, "шістнадцять леї, один бан"), (21.00, "двадцять один лей, нуль бані"), (37.73, "тридцять сім леї, сімдесят три бані"), (81.25, "вісімдесят один лей, двадцять п'ять бані"), (100.00, "сто леї, нуль бані"), (101.11, "сто один лей, одинадцять бані"), (10222, "сто два леї, двадцять два бані"), ) TEST_CASES_TO_CURRENCY_RSD = ( (0.00, "нуль динарів, нуль пар"), (1.00, "один динар, нуль пар"), (2.00, "два динари, нуль пар"), (5.00, "п'ять динарів, нуль пар"), (11.00, "одинадцять динарів, нуль пар"), (16.01, "шістнадцять динарів, одна пара"), (21.00, "двадцять один динар, нуль пар"), (37.73, "тридцять сім динарів, сімдесят три пари"), (81.25, "вісімдесят один динар, двадцять п'ять пар"), (100.00, "сто динарів, нуль пар"), (101.11, "сто один динар, одинадцять пар"), (10222, "сто два динари, двадцять дві пари"), ) TEST_CASES_TO_CURRENCY_RUB = ( (0.00, "нуль рублів, нуль копійок"), (1.00, "один рубль, нуль копійок"), (2.00, "два рублі, нуль копійок"), (5.00, "п'ять рублів, нуль копійок"), (11.00, "одинадцять рублів, нуль копійок"), (16.01, "шістнадцять рублів, одна копійка"), (21.00, "двадцять один рубль, нуль копійок"), (37.73, "тридцять сім рублів, сімдесят три копійки"), (81.25, "вісімдесят один рубль, двадцять п'ять копійок"), (100.00, "сто рублів, нуль копійок"), (101.11, "сто один рубль, одинадцять копійок"), ) TEST_CASES_TO_CURRENCY_RWF = ( (0.00, "нуль франків, нуль сантимів"), (1.00, "один франк, нуль сантимів"), (2.00, "два франки, нуль сантимів"), (5.00, "п'ять франків, нуль сантимів"), (11.00, "одинадцять франків, нуль сантимів"), (16.01, "шістнадцять франків, один сантим"), (21.00, "двадцять один франк, нуль сантимів"), (37.73, "тридцять сім франків, сімдесят три сантими"), (81.25, "вісімдесят один франк, двадцять п'ять сантимів"), (100.00, "сто франків, нуль сантимів"), (101.11, "сто один франк, одинадцять сантимів"), (10222, "сто два франки, двадцять два сантими"), ) TEST_CASES_TO_CURRENCY_SAR = ( (0.00, "нуль ріалів, нуль халалів"), (1.00, "один ріал, нуль халалів"), (2.00, "два ріали, нуль халалів"), (5.00, "п'ять ріалів, нуль халалів"), (11.00, "одинадцять ріалів, нуль халалів"), (16.01, "шістнадцять ріалів, один халал"), (21.00, "двадцять один ріал, нуль халалів"), (37.73, "тридцять сім ріалів, сімдесят три халали"), (81.25, "вісімдесят один ріал, двадцять п'ять халалів"), (100.00, "сто ріалів, нуль халалів"), (101.11, "сто один ріал, одинадцять халалів"), (10222, "сто два ріали, двадцять два халали"), ) TEST_CASES_TO_CURRENCY_SBD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_SCR = ( (0.00, "нуль рупій, нуль центів"), (1.00, "одна рупія, нуль центів"), (2.00, "дві рупії, нуль центів"), (5.00, "п'ять рупій, нуль центів"), (11.00, "одинадцять рупій, нуль центів"), (16.01, "шістнадцять рупій, один цент"), (21.00, "двадцять одна рупія, нуль центів"), (37.73, "тридцять сім рупій, сімдесят три центи"), (81.25, "вісімдесят одна рупія, двадцять п'ять центів"), (100.00, "сто рупій, нуль центів"), (101.11, "сто одна рупія, одинадцять центів"), (10222, "сто дві рупії, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_SDG = ( (0.00, "нуль фунтів, нуль піастрів"), (1.00, "один фунт, нуль піастрів"), (2.00, "два фунти, нуль піастрів"), (5.00, "п'ять фунтів, нуль піастрів"), (11.00, "одинадцять фунтів, нуль піастрів"), (16.01, "шістнадцять фунтів, один піастр"), (21.00, "двадцять один фунт, нуль піастрів"), (37.73, "тридцять сім фунтів, сімдесят три піастри"), (81.25, "вісімдесят один фунт, двадцять п'ять піастрів"), (100.00, "сто фунтів, нуль піастрів"), (101.11, "сто один фунт, одинадцять піастрів"), (10222, "сто два фунти, двадцять два піастри"), ) TEST_CASES_TO_CURRENCY_SEK = ( (0.00, "нуль крон, нуль ере"), (1.00, "одна крона, нуль ере"), (2.00, "дві крони, нуль ере"), (5.00, "п'ять крон, нуль ере"), (11.00, "одинадцять крон, нуль ере"), (16.01, "шістнадцять крон, один ере"), (21.00, "двадцять одна крона, нуль ере"), (37.73, "тридцять сім крон, сімдесят три ере"), (81.25, "вісімдесят одна крона, двадцять п'ять ере"), (100.00, "сто крон, нуль ере"), (101.11, "сто одна крона, одинадцять ере"), (10222, "сто дві крони, двадцять два ере"), ) TEST_CASES_TO_CURRENCY_SGD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_SHP = ( (0.00, "нуль фунтів, нуль пенсів"), (1.00, "один фунт, нуль пенсів"), (2.00, "два фунти, нуль пенсів"), (5.00, "п'ять фунтів, нуль пенсів"), (11.00, "одинадцять фунтів, нуль пенсів"), (16.01, "шістнадцять фунтів, один пенс"), (21.00, "двадцять один фунт, нуль пенсів"), (37.73, "тридцять сім фунтів, сімдесят три пенси"), (81.25, "вісімдесят один фунт, двадцять п'ять пенсів"), (100.00, "сто фунтів, нуль пенсів"), (101.11, "сто один фунт, одинадцять пенсів"), (10222, "сто два фунти, двадцять два пенси"), ) TEST_CASES_TO_CURRENCY_SLL = ( (0.00, "нуль леоне, нуль центів"), (1.00, "один леоне, нуль центів"), (2.00, "два леоне, нуль центів"), (5.00, "п'ять леоне, нуль центів"), (11.00, "одинадцять леоне, нуль центів"), (16.01, "шістнадцять леоне, один цент"), (21.00, "двадцять один леоне, нуль центів"), (37.73, "тридцять сім леоне, сімдесят три центи"), (81.25, "вісімдесят один леоне, двадцять п'ять центів"), (100.00, "сто леоне, нуль центів"), (101.11, "сто один леоне, одинадцять центів"), (10222, "сто два леоне, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_SOS = ( (0.00, "нуль шилінгів, нуль центів"), (1.00, "один шилінг, нуль центів"), (2.00, "два шилінги, нуль центів"), (5.00, "п'ять шилінгів, нуль центів"), (11.00, "одинадцять шилінгів, нуль центів"), (16.01, "шістнадцять шилінгів, один цент"), (21.00, "двадцять один шилінг, нуль центів"), (37.73, "тридцять сім шилінгів, сімдесят три центи"), (81.25, "вісімдесят один шилінг, двадцять п'ять центів"), (100.00, "сто шилінгів, нуль центів"), (101.11, "сто один шилінг, одинадцять центів"), (10222, "сто два шилінги, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_SRD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_SSP = ( (0.00, "нуль фунтів, нуль піастрів"), (1.00, "один фунт, нуль піастрів"), (2.00, "два фунти, нуль піастрів"), (5.00, "п'ять фунтів, нуль піастрів"), (11.00, "одинадцять фунтів, нуль піастрів"), (16.01, "шістнадцять фунтів, один піастр"), (21.00, "двадцять один фунт, нуль піастрів"), (37.73, "тридцять сім фунтів, сімдесят три піастри"), (81.25, "вісімдесят один фунт, двадцять п'ять піастрів"), (100.00, "сто фунтів, нуль піастрів"), (101.11, "сто один фунт, одинадцять піастрів"), (10222, "сто два фунти, двадцять два піастри"), ) TEST_CASES_TO_CURRENCY_STN = ( (0.00, "нуль добр, нуль сентімо"), (1.00, "одна добра, нуль сентімо"), (2.00, "дві добри, нуль сентімо"), (5.00, "п'ять добр, нуль сентімо"), (11.00, "одинадцять добр, нуль сентімо"), (16.01, "шістнадцять добр, один сентімо"), (21.00, "двадцять одна добра, нуль сентімо"), (37.73, "тридцять сім добр, сімдесят три сентімо"), (81.25, "вісімдесят одна добра, двадцять п'ять сентімо"), (100.00, "сто добр, нуль сентімо"), (101.11, "сто одна добра, одинадцять сентімо"), (10222, "сто дві добри, двадцять два сентімо"), ) TEST_CASES_TO_CURRENCY_SYP = ( (0.00, "нуль фунтів, нуль піастрів"), (1.00, "один фунт, нуль піастрів"), (2.00, "два фунти, нуль піастрів"), (5.00, "п'ять фунтів, нуль піастрів"), (11.00, "одинадцять фунтів, нуль піастрів"), (16.01, "шістнадцять фунтів, один піастр"), (21.00, "двадцять один фунт, нуль піастрів"), (37.73, "тридцять сім фунтів, сімдесят три піастри"), (81.25, "вісімдесят один фунт, двадцять п'ять піастрів"), (100.00, "сто фунтів, нуль піастрів"), (101.11, "сто один фунт, одинадцять піастрів"), (10222, "сто два фунти, двадцять два піастри"), ) TEST_CASES_TO_CURRENCY_SZL = ( (0.00, "нуль ліланґені, нуль центів"), (1.00, "один ліланґені, нуль центів"), (2.00, "два ліланґені, нуль центів"), (5.00, "п'ять ліланґені, нуль центів"), (11.00, "одинадцять ліланґені, нуль центів"), (16.01, "шістнадцять ліланґені, один цент"), (21.00, "двадцять один ліланґені, нуль центів"), (37.73, "тридцять сім ліланґені, сімдесят три центи"), (81.25, "вісімдесят один ліланґені, двадцять п'ять центів"), (100.00, "сто ліланґені, нуль центів"), (101.11, "сто один ліланґені, одинадцять центів"), (10222, "сто два ліланґені, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_THB = ( (0.00, "нуль батів, нуль сатангів"), (1.00, "один бат, нуль сатангів"), (2.00, "два бати, нуль сатангів"), (5.00, "п'ять батів, нуль сатангів"), (11.00, "одинадцять батів, нуль сатангів"), (16.01, "шістнадцять батів, один сатанг"), (21.00, "двадцять один бат, нуль сатангів"), (37.73, "тридцять сім батів, сімдесят три сатанги"), (81.25, "вісімдесят один бат, двадцять п'ять сатангів"), (100.00, "сто батів, нуль сатангів"), (101.11, "сто один бат, одинадцять сатангів"), (10222, "сто два бати, двадцять два сатанги"), ) TEST_CASES_TO_CURRENCY_TJS = ( (0.00, "нуль сомоні, нуль дірамів"), (1.00, "один сомоні, нуль дірамів"), (2.00, "два сомоні, нуль дірамів"), (5.00, "п'ять сомоні, нуль дірамів"), (11.00, "одинадцять сомоні, нуль дірамів"), (16.01, "шістнадцять сомоні, один дірам"), (21.00, "двадцять один сомоні, нуль дірамів"), (37.73, "тридцять сім сомоні, сімдесят три дірами"), (81.25, "вісімдесят один сомоні, двадцять п'ять дірамів"), (100.00, "сто сомоні, нуль дірамів"), (101.11, "сто один сомоні, одинадцять дірамів"), (10222, "сто два сомоні, двадцять два дірами"), ) TEST_CASES_TO_CURRENCY_TMT = ( (0.00, "нуль манатів, нуль тенге"), (1.00, "один манат, нуль тенге"), (2.00, "два манати, нуль тенге"), (5.00, "п'ять манатів, нуль тенге"), (11.00, "одинадцять манатів, нуль тенге"), (16.01, "шістнадцять манатів, один тенге"), (21.00, "двадцять один манат, нуль тенге"), (37.73, "тридцять сім манатів, сімдесят три тенге"), (81.25, "вісімдесят один манат, двадцять п'ять тенге"), (100.00, "сто манатів, нуль тенге"), (101.11, "сто один манат, одинадцять тенге"), (10222, "сто два манати, двадцять два тенге"), ) TEST_CASES_TO_CURRENCY_TND = ( (0.00, "нуль динарів, нуль міллімів"), (1.00, "один динар, нуль міллімів"), (2.00, "два динари, нуль міллімів"), (5.00, "п'ять динарів, нуль міллімів"), (11.00, "одинадцять динарів, нуль міллімів"), (16.01, "шістнадцять динарів, один міллім"), (21.00, "двадцять один динар, нуль міллімів"), (37.73, "тридцять сім динарів, сімдесят три мілліми"), (81.25, "вісімдесят один динар, двадцять п'ять міллімів"), (100.00, "сто динарів, нуль міллімів"), (101.11, "сто один динар, одинадцять міллімів"), (10222, "сто два динари, двадцять два мілліми"), ) TEST_CASES_TO_CURRENCY_TOP = ( (0.00, "нуль паанга, нуль сеніті"), (1.00, "один паанга, нуль сеніті"), (2.00, "два паанга, нуль сеніті"), (5.00, "п'ять паанга, нуль сеніті"), (11.00, "одинадцять паанга, нуль сеніті"), (16.01, "шістнадцять паанга, один сеніті"), (21.00, "двадцять один паанга, нуль сеніті"), (37.73, "тридцять сім паанга, сімдесят три сеніті"), (81.25, "вісімдесят один паанга, двадцять п'ять сеніті"), (100.00, "сто паанга, нуль сеніті"), (101.11, "сто один паанга, одинадцять сеніті"), (10222, "сто два паанга, двадцять два сеніті"), ) TEST_CASES_TO_CURRENCY_TRY = ( (0.00, "нуль лір, нуль курушів"), (1.00, "одна ліра, нуль курушів"), (2.00, "дві ліри, нуль курушів"), (5.00, "п'ять лір, нуль курушів"), (11.00, "одинадцять лір, нуль курушів"), (16.01, "шістнадцять лір, один куруш"), (21.00, "двадцять одна ліра, нуль курушів"), (37.73, "тридцять сім лір, сімдесят три куруші"), (81.25, "вісімдесят одна ліра, двадцять п'ять курушів"), (100.00, "сто лір, нуль курушів"), (101.11, "сто одна ліра, одинадцять курушів"), (10222, "сто дві ліри, двадцять два куруші"), ) TEST_CASES_TO_CURRENCY_TTD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_TWD = ( (0.00, "нуль нових доларів, нуль центів"), (1.00, "один новий долар, нуль центів"), (2.00, "два нові долари, нуль центів"), (5.00, "п'ять нових доларів, нуль центів"), (11.00, "одинадцять нових доларів, нуль центів"), (16.01, "шістнадцять нових доларів, один цент"), (21.00, "двадцять один новий долар, нуль центів"), (37.73, "тридцять сім нових доларів, сімдесят три центи"), (81.25, "вісімдесят один новий долар, двадцять п'ять центів"), (100.00, "сто нових доларів, нуль центів"), (101.11, "сто один новий долар, одинадцять центів"), (10222, "сто два нові долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_TZS = ( (0.00, "нуль шилінгів, нуль центів"), (1.00, "один шилінг, нуль центів"), (2.00, "два шилінги, нуль центів"), (5.00, "п'ять шилінгів, нуль центів"), (11.00, "одинадцять шилінгів, нуль центів"), (16.01, "шістнадцять шилінгів, один цент"), (21.00, "двадцять один шилінг, нуль центів"), (37.73, "тридцять сім шилінгів, сімдесят три центи"), (81.25, "вісімдесят один шилінг, двадцять п'ять центів"), (100.00, "сто шилінгів, нуль центів"), (101.11, "сто один шилінг, одинадцять центів"), (10222, "сто два шилінги, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_UAH = ( (0.00, "нуль гривень, нуль копійок"), (1.00, "одна гривня, нуль копійок"), (2.00, "дві гривні, нуль копійок"), (5.00, "п'ять гривень, нуль копійок"), (11.00, "одинадцять гривень, нуль копійок"), (16.01, "шістнадцять гривень, одна копійка"), (21.00, "двадцять одна гривня, нуль копійок"), (37.73, "тридцять сім гривень, сімдесят три копійки"), (81.25, "вісімдесят одна гривня, двадцять п'ять копійок"), (100.00, "сто гривень, нуль копійок"), (101.11, "сто одна гривня, одинадцять копійок"), (10222, "сто дві гривні, двадцять дві копійки"), ) TEST_CASES_TO_CURRENCY_UGX = ( (0.00, "нуль шилінгів, нуль центів"), (1.00, "один шилінг, нуль центів"), (2.00, "два шилінги, нуль центів"), (5.00, "п'ять шилінгів, нуль центів"), (11.00, "одинадцять шилінгів, нуль центів"), (16.01, "шістнадцять шилінгів, один цент"), (21.00, "двадцять один шилінг, нуль центів"), (37.73, "тридцять сім шилінгів, сімдесят три центи"), (81.25, "вісімдесят один шилінг, двадцять п'ять центів"), (100.00, "сто шилінгів, нуль центів"), (101.11, "сто один шилінг, одинадцять центів"), (10222, "сто два шилінги, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_USD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_UYU = ( (0.00, "нуль песо, нуль сентесімо"), (1.00, "один песо, нуль сентесімо"), (2.00, "два песо, нуль сентесімо"), (5.00, "п'ять песо, нуль сентесімо"), (11.00, "одинадцять песо, нуль сентесімо"), (16.01, "шістнадцять песо, один сентесімо"), (21.00, "двадцять один песо, нуль сентесімо"), (37.73, "тридцять сім песо, сімдесят три сентесімо"), (81.25, "вісімдесят один песо, двадцять п'ять сентесімо"), (100.00, "сто песо, нуль сентесімо"), (101.11, "сто один песо, одинадцять сентесімо"), (10222, "сто два песо, двадцять два сентесімо"), ) TEST_CASES_TO_CURRENCY_UZS = ( (0.00, "нуль сумів, нуль тиїнів"), (1.00, "один сум, нуль тиїнів"), (2.00, "два суми, нуль тиїнів"), (5.00, "п'ять сумів, нуль тиїнів"), (11.00, "одинадцять сумів, нуль тиїнів"), (16.01, "шістнадцять сумів, один тиїн"), (21.00, "двадцять один сум, нуль тиїнів"), (37.73, "тридцять сім сумів, сімдесят три тиїни"), (81.25, "вісімдесят один сум, двадцять п'ять тиїнів"), (100.00, "сто сумів, нуль тиїнів"), (101.11, "сто один сум, одинадцять тиїнів"), (10222, "сто два суми, двадцять два тиїни"), ) TEST_CASES_TO_CURRENCY_VND = ( (0.00, "нуль донгів, нуль су"), (1.00, "один донг, нуль су"), (2.00, "два донги, нуль су"), (5.00, "п'ять донгів, нуль су"), (11.00, "одинадцять донгів, нуль су"), (16.01, "шістнадцять донгів, один су"), (21.00, "двадцять один донг, нуль су"), (37.73, "тридцять сім донгів, сімдесят три су"), (81.25, "вісімдесят один донг, двадцять п'ять су"), (100.00, "сто донгів, нуль су"), (101.11, "сто один донг, одинадцять су"), (10222, "сто два донги, двадцять два су"), ) TEST_CASES_TO_CURRENCY_WST = ( (0.00, "нуль тал, нуль сене"), (1.00, "одна тала, нуль сене"), (2.00, "дві тали, нуль сене"), (5.00, "п'ять тал, нуль сене"), (11.00, "одинадцять тал, нуль сене"), (16.01, "шістнадцять тал, один сене"), (21.00, "двадцять одна тала, нуль сене"), (37.73, "тридцять сім тал, сімдесят три сене"), (81.25, "вісімдесят одна тала, двадцять п'ять сене"), (100.00, "сто тал, нуль сене"), (101.11, "сто одна тала, одинадцять сене"), (10222, "сто дві тали, двадцять два сене"), ) TEST_CASES_TO_CURRENCY_XCD = ( (0.00, "нуль доларів, нуль центів"), (1.00, "один долар, нуль центів"), (2.00, "два долари, нуль центів"), (5.00, "п'ять доларів, нуль центів"), (11.00, "одинадцять доларів, нуль центів"), (16.01, "шістнадцять доларів, один цент"), (21.00, "двадцять один долар, нуль центів"), (37.73, "тридцять сім доларів, сімдесят три центи"), (81.25, "вісімдесят один долар, двадцять п'ять центів"), (100.00, "сто доларів, нуль центів"), (101.11, "сто один долар, одинадцять центів"), (10222, "сто два долари, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_YER = ( (0.00, "нуль ріалів, нуль філсів"), (1.00, "один ріал, нуль філсів"), (2.00, "два ріали, нуль філсів"), (5.00, "п'ять ріалів, нуль філсів"), (11.00, "одинадцять ріалів, нуль філсів"), (16.01, "шістнадцять ріалів, один філс"), (21.00, "двадцять один ріал, нуль філсів"), (37.73, "тридцять сім ріалів, сімдесят три філси"), (81.25, "вісімдесят один ріал, двадцять п'ять філсів"), (100.00, "сто ріалів, нуль філсів"), (101.11, "сто один ріал, одинадцять філсів"), (10222, "сто два ріали, двадцять два філси"), ) TEST_CASES_TO_CURRENCY_ZAR = ( (0.00, "нуль рандів, нуль центів"), (1.00, "один ранд, нуль центів"), (2.00, "два ранди, нуль центів"), (5.00, "п'ять рандів, нуль центів"), (11.00, "одинадцять рандів, нуль центів"), (16.01, "шістнадцять рандів, один цент"), (21.00, "двадцять один ранд, нуль центів"), (37.73, "тридцять сім рандів, сімдесят три центи"), (81.25, "вісімдесят один ранд, двадцять п'ять центів"), (100.00, "сто рандів, нуль центів"), (101.11, "сто один ранд, одинадцять центів"), (10222, "сто два ранди, двадцять два центи"), ) TEST_CASES_TO_CURRENCY_ZMW = ( (0.00, "нуль квач, нуль нгве"), (1.00, "одна квача, нуль нгве"), (2.00, "дві квачі, нуль нгве"), (5.00, "п'ять квач, нуль нгве"), (11.00, "одинадцять квач, нуль нгве"), (16.01, "шістнадцять квач, один нгве"), (21.00, "двадцять одна квача, нуль нгве"), (37.73, "тридцять сім квач, сімдесят три нгве"), (81.25, "вісімдесят одна квача, двадцять п'ять нгве"), (100.00, "сто квач, нуль нгве"), (101.11, "сто одна квача, одинадцять нгве"), (10222, "сто дві квачі, двадцять два нгве"), ) class Num2WordsUKTest(TestCase): def test_to_cardinal(self): for test in TEST_CASES_CARDINAL: self.assertEqual(num2words(test[0], lang='uk'), test[1]) def test_to_cardinal_feminine(self): for test in TEST_CASES_CARDINAL_FEMININE: word = num2words(test[0], lang='uk', gender='feminine') self.assertEqual(word, test[1]) def test_to_cardinal_nominative(self): for test in TEST_CASES_CARDINAL: word = num2words(test[0], lang='uk', case='nominative') self.assertEqual(word, test[1]) def test_to_cardinal_genitive(self): for test in TEST_CASES_CARDINAL_GENITIVE: word = num2words(test[0], lang='uk', case='genitive') self.assertEqual(word, test[1]) def test_to_cardinal_dative(self): self.maxDiff = None for test in TEST_CASES_CARDINAL_DATIVE: word = num2words(test[0], lang='uk', case='dative') self.assertEqual(word, test[1]) def test_to_cardinal_accusative(self): self.maxDiff = None for test in TEST_CASES_CARDINAL_ACCUSATIVE: word = num2words(test[0], lang='uk', case='accusative') self.assertEqual(word, test[1]) def test_to_cardinal_instrumental(self): self.maxDiff = None for test in TEST_CASES_CARDINAL_INSTRUMENTAL: word = num2words(test[0], lang='uk', case='instrumental') self.assertEqual(word, test[1]) def test_to_cardinal_locative(self): self.maxDiff = None for test in TEST_CASES_CARDINAL_LOCATIVE: word = num2words(test[0], lang='uk', case='locative') self.assertEqual(word, test[1]) def test_to_ordinal(self): for test in TEST_CASES_ORDINAL: self.assertEqual( num2words(test[0], lang='uk', to='ordinal'), test[1] ) def test_to_currency(self): for test in TEST_CASES_TO_CURRENCY_AED: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AED"), test[1] ) for test in TEST_CASES_TO_CURRENCY_AFN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AFN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ALL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ALL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_AMD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AMD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ANG: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ANG"), test[1] ) for test in TEST_CASES_TO_CURRENCY_AOA: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AOA"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ARS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ARS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_AUD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AUD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_AWG: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AWG"), test[1] ) for test in TEST_CASES_TO_CURRENCY_AZN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="AZN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BAM: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BAM"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BBD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BBD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BDT: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BDT"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BGN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BGN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BHD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BHD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BIF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BIF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BMD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BMD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BND: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BND"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BOB: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BOB"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BRL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BRL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BSD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BSD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BTN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BTN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BWP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BWP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BYN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BYN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_BZD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="BZD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CAD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CAD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CDF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CDF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CHF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CHF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CLP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CLP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CNY: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CNY"), test[1] ) for test in TEST_CASES_TO_CURRENCY_COP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="COP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CRC: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CRC"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CUC: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CUC"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CUP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CUP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CVE: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CVE"), test[1] ) for test in TEST_CASES_TO_CURRENCY_CZK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="CZK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_DJF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="DJF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_DKK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="DKK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_DOP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="DOP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_DZD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="DZD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_EGP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="EGP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ERN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ERN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ETB: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ETB"), test[1] ) for test in TEST_CASES_TO_CURRENCY_EUR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="EUR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_FJD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="FJD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_FKP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="FKP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GBP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GBP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GEL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GEL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GHS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GHS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GIP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GIP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GMD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GMD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GNF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GNF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GTQ: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GTQ"), test[1] ) for test in TEST_CASES_TO_CURRENCY_GYD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="GYD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_HKD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="HKD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_HNL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="HNL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_HRK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="HRK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_HTG: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="HTG"), test[1] ) for test in TEST_CASES_TO_CURRENCY_HUF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="HUF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_IDR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="IDR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ILS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ILS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_INR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="INR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_IQD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="IQD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_IRR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="IRR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ISK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ISK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_JMD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="JMD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_JOD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="JOD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_JPY: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="JPY"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KES: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KES"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KGS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KGS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KHR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KHR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KMF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KMF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KPW: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KPW"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KRW: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KRW"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KWD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KWD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KYD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KYD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_KZT: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="KZT"), test[1] ) for test in TEST_CASES_TO_CURRENCY_LAK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="LAK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_LBP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="LBP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_LKR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="LKR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_LRD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="LRD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_LSL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="LSL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_LYD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="LYD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MAD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MAD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MDL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MDL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MGA: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MGA"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MKD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MKD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MMK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MMK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MNT: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MNT"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MOP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MOP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MRU: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MRU"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MUR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MUR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MVR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MVR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MWK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MWK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MXN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MXN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MYR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MYR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_MZN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="MZN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_NAD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="NAD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_NGN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="NGN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_NIO: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="NIO"), test[1] ) for test in TEST_CASES_TO_CURRENCY_NOK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="NOK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_NPR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="NPR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_NZD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="NZD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_OMR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="OMR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PAB: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PAB"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PEN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PEN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PGK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PGK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PHP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PHP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PKR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PKR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PLN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PLN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_PYG: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="PYG"), test[1] ) for test in TEST_CASES_TO_CURRENCY_QAR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="QAR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_RON: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="RON"), test[1] ) for test in TEST_CASES_TO_CURRENCY_RSD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="RSD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_RUB: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="RUB"), test[1] ) for test in TEST_CASES_TO_CURRENCY_RWF: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="RWF"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SAR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SAR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SBD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SBD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SCR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SCR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SDG: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SDG"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SEK: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SEK"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SGD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SGD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SHP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SHP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SLL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SLL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SOS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SOS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SRD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SRD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SSP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SSP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_STN: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="STN"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SYP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SYP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_SZL: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="SZL"), test[1] ) for test in TEST_CASES_TO_CURRENCY_THB: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="THB"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TJS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TJS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TMT: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TMT"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TND: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TND"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TOP: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TOP"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TRY: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TRY"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TTD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TTD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TWD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TWD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_TZS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="TZS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_UAH: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="UAH"), test[1] ) for test in TEST_CASES_TO_CURRENCY_UGX: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="UGX"), test[1] ) for test in TEST_CASES_TO_CURRENCY_USD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="USD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_UYU: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="UYU"), test[1] ) for test in TEST_CASES_TO_CURRENCY_UZS: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="UZS"), test[1] ) for test in TEST_CASES_TO_CURRENCY_VND: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="VND"), test[1] ) for test in TEST_CASES_TO_CURRENCY_WST: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="WST"), test[1] ) for test in TEST_CASES_TO_CURRENCY_XCD: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="XCD"), test[1] ) for test in TEST_CASES_TO_CURRENCY_YER: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="YER"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ZAR: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ZAR"), test[1] ) for test in TEST_CASES_TO_CURRENCY_ZMW: self.assertEqual( num2words(test[0], lang='uk', to='currency', currency="ZMW"), test[1] ) num2words-0.5.14/tests/test_utils.py000066400000000000000000000034651473005321200174610ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words.utils import splitbyx class TestUtils(TestCase): def test_splitbyx(self): self.assertEqual(list(splitbyx(str(12), 3)), [12]) self.assertEqual(list(splitbyx(str(1234), 3)), [1, 234]) self.assertEqual(list(splitbyx(str(12345678900), 3)), [12, 345, 678, 900] ) self.assertEqual(list(splitbyx(str(1000000), 6)), [1, 0]) self.assertEqual(list(splitbyx(str(12), 3, format_int=False)), ['12']) self.assertEqual(list(splitbyx(str(1234), 3, format_int=False)), ['1', '234'] ) self.assertEqual(list(splitbyx(str(12345678900), 3, format_int=False)), ['12', '345', '678', '900'] ) self.assertEqual(list(splitbyx(str(1000000), 6, format_int=False)), ['1', '000000'] ) num2words-0.5.14/tests/test_vi.py000066400000000000000000000137131473005321200167340ustar00rootroot00000000000000# -*- 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 unittest import TestCase from num2words import num2words class Num2WordsVITest(TestCase): def test_0(self): self.assertEqual(num2words(0, lang="vi"), "không") def test_1_to_10(self): self.assertEqual(num2words(1, lang="vi"), "một") self.assertEqual(num2words(2, lang="vi"), "hai") self.assertEqual(num2words(7, lang="vi"), "bảy") self.assertEqual(num2words(10, lang="vi"), "mười") def test_11_to_19(self): self.assertEqual(num2words(11, lang="vi"), "mười một") self.assertEqual(num2words(13, lang="vi"), "mười ba") self.assertEqual(num2words(14, lang="vi"), "mười bốn") self.assertEqual(num2words(15, lang="vi"), "mười lăm") self.assertEqual(num2words(16, lang="vi"), "mười sáu") self.assertEqual(num2words(19, lang="vi"), "mười chín") def test_20_to_99(self): self.assertEqual(num2words(20, lang="vi"), "hai mươi") self.assertEqual(num2words(23, lang="vi"), "hai mươi ba") self.assertEqual(num2words(28, lang="vi"), "hai mươi tám") self.assertEqual(num2words(31, lang="vi"), "ba mươi mốt") self.assertEqual(num2words(40, lang="vi"), "bốn mươi") self.assertEqual(num2words(66, lang="vi"), "sáu mươi sáu") self.assertEqual(num2words(92, lang="vi"), "chín mươi hai") def test_100_to_999(self): self.assertEqual(num2words(100, lang="vi"), "một trăm") self.assertEqual(num2words(150, lang="vi"), "một trăm năm mươi") self.assertEqual( num2words(196, lang="vi"), "một trăm chín mươi sáu" ) self.assertEqual(num2words(200, lang="vi"), "hai trăm") self.assertEqual(num2words(210, lang="vi"), "hai trăm mười") def test_1000_to_9999(self): self.assertEqual(num2words(1000, lang="vi"), "một nghìn") self.assertEqual(num2words(1500, lang="vi"), "một nghìn năm trăm") self.assertEqual( num2words(7378, lang="vi"), "bảy nghìn ba trăm bảy mươi tám" ) self.assertEqual(num2words(2000, lang="vi"), "hai nghìn") self.assertEqual(num2words(2100, lang="vi"), "hai nghìn một trăm") self.assertEqual( num2words(6870, lang="vi"), "sáu nghìn tám trăm bảy mươi" ) self.assertEqual(num2words(10000, lang="vi"), "mười nghìn") self.assertEqual(num2words(100000, lang="vi"), "một trăm nghìn") self.assertEqual( num2words(523456, lang="vi"), "năm trăm hai mươi ba nghìn bốn trăm năm mươi sáu" ) def test_big(self): self.assertEqual(num2words(1000000, lang="vi"), "một triệu") self.assertEqual( num2words(1200000, lang="vi"), "một triệu hai trăm nghìn" ) self.assertEqual(num2words(3000000, lang="vi"), "ba triệu") self.assertEqual( num2words(3800000, lang="vi"), "ba triệu tám trăm nghìn" ) self.assertEqual(num2words(1000000000, lang="vi"), "một tỷ") self.assertEqual(num2words(2000000000, lang="vi"), "hai tỷ") self.assertEqual( num2words(2000001000, lang="vi"), "hai tỷ một nghìn" ) self.assertEqual( num2words(1234567890, lang="vi"), "một tỷ hai trăm ba mươi bốn triệu năm trăm sáu mươi bảy nghìn " "tám trăm chín mươi" ) def test_decimal_number(self): self.assertEqual( num2words(1000.11, lang="vi"), "một nghìn phẩy mười một" ) self.assertEqual( num2words(1000.21, lang="vi"), "một nghìn phẩy hai mươi mốt" ) def test_special_number(self): """ Some number will have some specail rule """ self.assertEqual(num2words(21, lang="vi"), "hai mươi mốt") self.assertEqual(num2words(25, lang="vi"), "hai mươi lăm") # >100 self.assertEqual(num2words(101, lang="vi"), "một trăm lẻ một") self.assertEqual(num2words(105, lang="vi"), "một trăm lẻ năm") self.assertEqual(num2words(701, lang="vi"), "bảy trăm lẻ một") self.assertEqual(num2words(705, lang="vi"), "bảy trăm lẻ năm") # >1000 self.assertEqual(num2words(1001, lang="vi"), "một nghìn lẻ một") self.assertEqual(num2words(1005, lang="vi"), "một nghìn lẻ năm") self.assertEqual( num2words(98765, lang="vi"), "chín mươi tám nghìn bảy trăm sáu mươi lăm" ) # > 1000000 self.assertEqual(num2words(3000005, lang="vi"), "ba triệu lẻ năm") self.assertEqual(num2words(1000007, lang="vi"), "một triệu lẻ bảy") # > 1000000000 self.assertEqual( num2words(1000000017, lang="vi"), "một tỷ lẻ mười bảy" ) self.assertEqual( num2words(1000101017, lang="vi"), "một tỷ một trăm lẻ một nghìn lẻ mười bảy" ) num2words-0.5.14/tox.ini000066400000000000000000000012651473005321200150550ustar00rootroot00000000000000[tox] envlist = py37,py38,py39,py310,py311,py312,flake8,isort [gh-actions] python = 3.7: py37 3.8: py38 3.9: py39 3.10: isort, flake8, py310 3.11: py311 3.12: py312 [testenv] passenv = GITHUB_* deps = coverage delegator.py commands = coverage run -m unittest discover coverage report --fail-under=75 --omit=.tox/*,tests/*,/usr/* coverage report --fail-under=100 --include=tests/* --skip-covered [testenv:flake8] changedir = {toxinidir} deps = flake8==5.0.4 flake8-copyright commands = flake8 [testenv:isort] changedir = {toxinidir} deps = isort delegator.py commands = isort --check-only --float-to-top --diff num2words tests