WeTextProcessing 1.0.6.dev19__py3-none-any.whl → 1.3.0__py3-none-any.whl

itn/README.md

@@ -3,15 +3,23 @@
 ### 1. How To Use
 
 ``` bash
-$ python inverse_normalize.py --text "text to be denormalized"
+$ python -m itn --language zh --text "二点五平方电线"
+# Or, after installation:
+$ weitn --language zh --text "二点五平方电线"
 ```
 
 ### 2. ITN Pipeline
 
-There are 2 components in ITN pipeline:
+There are 3 logical components in the ITN pipeline:
 
-* pre-processing (before tagger)
-* non-standard word denormalization
+* optional input canonicalization
+* classification and raw-field tagging
+* non-standard word verbalization and output post-processing
+
+The tagger must preserve the spoken input in its fields. Converting those
+fields to written forms belongs to the verbalizer. See the
+[Python rule architecture and contribution guide](../docs/python-rule-architecture.md)
+before adding or modifying a rule.
 
 #### 2.1 Pre-Processing
 

itn/arabic/data/measure/measurements.tsv

@@ -0,0 +1,14 @@
+%	في المائة
+f	فهرنهايت
+°C	درجة مئوية
+°F	درجة فهرنهايت
+كم	كيلومتر
+كلم	كيلومتر
+م	متر
+سم	سنتيمتر
+ملم	مليمتر
+هم	هكتومتر
+م²	متر مربع
+كم²	كيلو متر مربع
+مم²	مليمتر مربع
+سم²	سنتيمتر مربع

itn/arabic/data/money/currency_major.tsv

@@ -0,0 +1,24 @@
+$	دولار
+$	دولار أمريكي
+US$	دولار أمريكي
+฿	بات تايلندي
+£	جنيه استرليني
+€	يورو
+₩	ين
+nzd	دولار نيوزيلندي
+rs	روبية
+chf	فرنك سويسري
+dkk	كرونة دنماركية
+aed	درهم إماراتي
+¥	ين ياباني
+mro	الأوقية الموريتانية
+pkr	روبية باكستانية
+hk$	دولار هونج كونج
+npr	روبية نيبالية
+sar	ريال سعودي
+dm	مارك ألماني
+cad	دولار الكندي
+DH	درهم
+Dh	درهم
+Dhs.	درهم
+₺	ليرة تركية

itn/arabic/data/money/currency_minor_plural.tsv

@@ -0,0 +1,4 @@
+$	سنتات
+US$	سنتات
+€	سنتات
+£	بنسات

itn/arabic/data/money/currency_minor_singular.tsv

@@ -0,0 +1,3 @@
+$	سنت
+€	سنت
+£	بنس

itn/arabic/data/money/local_currency.tsv

@@ -0,0 +1,20 @@
+ج.م	جنيه مصري
+د.ع	دينار عراقي
+د.ك	دينار كويتي
+أ.م	أوقية موريتانية
+د.إ	درهم إماراتي
+د.ب	دينار بحريني
+د.ج	دينار جزائري
+ج.س	جنيه سوداني
+د.أ	دينار أردني
+ر.س	ريال سعودي
+ر ق	ريال قطري
+ر.ع	ريال عماني
+ل.ل	ليرة لبنانية
+د.م	درهم مغربي
+د.ل	دينار ليبي
+د.ت	دينار تونسي
+ل.س	ليرة سورية
+ر.ي	ريال يمني
+ف.ج	فرنك جيبوتي
+ش.ص	شلن صومالي

itn/arabic/data/number/digit.tsv

@@ -0,0 +1,9 @@
+1	واحد
+2	اثنان
+3	ثلاثة
+4	أربعة
+5	خمسة
+6	ستة
+7	سبعة
+8	ثمانية
+9	تسعة

itn/arabic/data/number/digit_100.tsv

@@ -0,0 +1,7 @@
+3	ثلاث
+4	أربع
+5	خمس
+6	ست
+7	سبع
+8	ثمان
+9	تسع

itn/arabic/data/number/digit_1000.tsv

@@ -0,0 +1,7 @@
+3	ثلاثة
+4	أربعة
+5	خمسة
+6	ستة
+7	سبعة
+8	ثمانية
+9	تسعة

itn/arabic/data/number/flops.tsv

@@ -0,0 +1,72 @@
+21	12
+22	22
+23	32
+24	42
+25	52
+26	62
+27	72
+28	82
+29	92
+31	13
+32	23
+33	33
+34	43
+35	53
+36	63
+37	73
+38	83
+39	93
+41	14
+42	24
+43	34
+45	54
+46	64
+47	74
+48	84
+49	94
+44	44
+51	15
+52	25
+53	35
+54	45
+56	65
+57	75
+58	85
+59	95
+55	55
+61	16
+62	26
+63	36
+64	46
+65	56
+67	76
+68	86
+69	96
+66	66
+71	17
+72	27
+73	37
+74	47
+75	57
+76	67
+78	87
+79	97
+77	77
+81	18
+82	28
+83	38
+84	48
+85	58
+86	68
+87	78
+89	98
+88	88
+91	19
+92	29
+93	39
+94	49
+95	59
+96	69
+97	79
+98	89
+99	99

itn/arabic/data/number/fraction_dual.tsv

@@ -0,0 +1,9 @@
+2	نصفين
+3	ثلثين
+4	ربعين
+5	خمسين
+6	سدسين
+7	سبعين
+8	ثمنين
+9	تسعين
+10	عشرين

itn/arabic/data/number/fraction_plural.tsv

@@ -0,0 +1,8 @@
+3	أثلاث
+4	أرباع
+5	أخماس
+6	أسداس
+7	أسباع
+8	أثمان
+9	أتساع
+10	أعشار

itn/arabic/data/number/fraction_singular.tsv

@@ -0,0 +1,9 @@
+2	نصف
+3	ثلث
+4	ربع
+5	خمس
+6	سدس
+7	سبع
+8	ثمن
+9	تسع
+10	عشر

itn/arabic/data/number/quantities.tsv

@@ -0,0 +1,6 @@
+مليون
+مليار
+تريليون
+مليار
+بليار
+تريليون

itn/arabic/data/number/teens.tsv

@@ -0,0 +1,9 @@
+11	احد عشر
+12	اثنا عشر
+13	ثلاثة عشر
+14	اربعة عشر
+15	خمسة عشر
+16	ستة عشر
+17	سبعة عشر
+18	ثمانية عشر
+19	تسعة عشر

itn/arabic/data/number/tens.tsv

@@ -0,0 +1,10 @@
+1	عشرة
+2	عشرون
+3	ثلاثون
+4	أربعون
+5	خمسون
+6	ستون
+7	سبعون
+8	ثمانون
+9	تسعون
+10	مئة

itn/arabic/inverse_normalizer.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2026 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pynini.lib import pynutil
+
+from itn.arabic.rules import money
+from itn.arabic.rules.cardinal import Cardinal
+from itn.arabic.rules.decimal import Decimal
+from itn.arabic.rules.fraction import Fraction
+from itn.arabic.rules.measure import Measure
+from itn.arabic.rules.money import Money
+from itn.arabic.rules.punctuation import Punctuation
+from itn.arabic.rules.word import Word
+from tn.processor import Processor, RuleSpec
+
+TOKEN_ORDERS = {}
+for _module in (money, ):
+    TOKEN_ORDERS.update(_module.TOKEN_ORDER)
+
+
+class InverseNormalizer(Processor):
+
+    def __init__(self, cache_dir=None, overwrite_cache=False):
+        super().__init__(name="ar_inverse_normalizer", ordertype="itn", token_orders=TOKEN_ORDERS)
+        self.build_fst("ar_itn", cache_dir, overwrite_cache, {})
+
+    def build_tagger_and_verbalizer(self):
+        cardinal = Cardinal()
+        decimal = Decimal(cardinal)
+        fraction = Fraction(cardinal)
+        punctuation = Punctuation()
+        word = Word()
+        rules = (
+            RuleSpec(cardinal, 1.1),
+            RuleSpec(decimal, 1.1),
+            RuleSpec(fraction, 1.1),
+            RuleSpec(Money(cardinal), 1.1),
+            RuleSpec(Measure(cardinal, decimal, fraction), 1.1),
+            RuleSpec(word, 100),
+            RuleSpec(punctuation),
+        )
+        classify = self.tagger_union(rules)
+        punct = pynutil.add_weight(punctuation.tagger, 1.1)
+        token = punct.star + classify + punct.star
+        self.tagger = self.DELETE_SPACE + token + (self.DELETE_EXTRA_SPACE + token).star + self.DELETE_SPACE
+        self.tagger |= word.add_tokens(word.tag_field("value", self.SPACE.plus))
+        verbalize = self.verbalizer_union(rules)
+        self.verbalizer = verbalize + (self.INSERT_SPACE + verbalize).star

itn/arabic/rules/cardinal.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2026 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pynini
+from pynini.lib import byte
+from pynini.lib.pynutil import delete, insert
+
+from itn.utils import get_abs_path
+from tn.processor import Processor
+
+
+def spell_out():
+    """Written digits (1..9999) -> Arabic number words, one digit per place value."""
+
+    digit = pynini.string_file(get_abs_path("arabic/data/number/digit.tsv"))
+    digit_100 = pynini.string_file(get_abs_path("arabic/data/number/digit_100.tsv"))
+    digit_1000 = pynini.string_file(get_abs_path("arabic/data/number/digit_1000.tsv"))
+    teens = pynini.string_file(get_abs_path("arabic/data/number/teens.tsv"))
+    # tens.tsv also lists 10 -> مئة, which would let "100" pose as two digits.
+    tens = byte.DIGIT @ pynini.string_file(get_abs_path("arabic/data/number/tens.tsv"))
+    flops = pynini.string_file(get_abs_path("arabic/data/number/flops.tsv"))
+    conjunction = insert(" و")
+    two_digits = teens | tens + delete("0") | flops @ (digit + conjunction + tens)
+
+    def tail(width, lower):
+        # Round hundreds/thousands cost a little more, so a decimal like
+        # "مئة وواحد وخمسون من مئة" keeps the longer integer part (101.50).
+        rest = delete("0" * width, weight=0.001)
+        for zeros, graph in enumerate(lower):
+            rest |= delete("0" * zeros) + conjunction + graph
+        return rest
+
+    hundreds = pynini.union(pynini.cross("1", "مئة"), pynini.cross("2", "مئتان"), digit_100 + insert(" مئة"))
+    hundreds = (hundreds + tail(2, [two_digits, digit])).optimize()
+    thousands = pynini.union(pynini.cross("1", "ألف"), pynini.cross("2", "ألفان"), digit_1000 + insert(" اَلاف"))
+    thousands += tail(3, [hundreds, two_digits, digit])
+    return (digit | two_digits | hundreds | thousands).optimize()
+
+
+class Cardinal(Processor):
+    """Number words up to 9999, e.g. ``سالب تسعة وتسعون`` -> ``-99``.
+
+    The tagger keeps the spoken words; the verbalizer writes the digits.
+    """
+
+    def __init__(self):
+        super().__init__(name="cardinal", ordertype="itn")
+        self.spoken = spell_out()
+        self.graph = pynini.invert(self.spoken).optimize()
+        self.negative = pynini.cross("سالب", "-")
+        sign = self.tag_field("negative", self.negative) + delete(" ") + insert(" ")
+        self.tagger = self.add_tokens(sign.ques + self.tag_field("integer", self.graph))
+        sign_out = self.verbalize_field("negative", self.negative) + delete(" ")
+        self.verbalizer = self.delete_tokens(sign_out.ques + self.verbalize_field("integer", self.graph))

itn/arabic/rules/decimal.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2026 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pynini
+from pynini.lib.pynutil import delete, insert
+
+from itn.utils import get_abs_path
+from tn.processor import Processor
+
+
+class Decimal(Processor):
+    """Decimals, e.g. ``ستة وثمانية وثمانون من مئة`` -> ``6.88``.
+
+    The spoken denominator (عشرة, مئة, ألف, عشرة آلاف) fixes the number of
+    fractional digits. The tagger keeps the words, dropping only the ``و``
+    that joins the two parts.
+    """
+
+    def __init__(self, cardinal):
+        super().__init__(name="decimal", ordertype="itn")
+        self.cardinal = cardinal
+        padded = delete("0").star + cardinal.spoken
+        denominators = ["عشرة", "مئة", "ألف", "عشرة آلاف"]
+        fractional = pynini.union(*[
+            self.DIGIT**width @ padded + insert(" من " + denominator)
+            for width, denominator in enumerate(denominators, 1)
+        ])
+        self.fractional = pynini.invert(fractional).optimize()
+        self.quantity = pynini.string_file(get_abs_path("arabic/data/number/quantities.tsv")).optimize()
+        self.negative = cardinal.negative
+        sign = self.tag_field("negative", self.negative) + self.DELETE_EXTRA_SPACE
+        self.tagger = self.add_tokens(sign.ques + self.tag_number())
+        sign_out = self.verbalize_field("negative", self.negative) + delete(" ")
+        self.verbalizer = self.delete_tokens(sign_out.ques + self.verbalize_number())
+
+    def tag_number(self):
+        """Raw decimal fields without the sign, shared with measure."""
+
+        tagger = self.tag_field("integer_part", self.cardinal.graph) + pynini.accep(" ") + delete("و")
+        tagger += self.tag_field("fractional_part", self.fractional)
+        return tagger + (pynini.accep(" ") + self.tag_field("quantity", self.quantity)).ques
+
+    def verbalize_number(self):
+        verbalizer = self.verbalize_field("integer_part", self.cardinal.graph) + insert(".")
+        verbalizer += self.verbalize_field("fractional_part", self.fractional, True)
+        return verbalizer + (insert(" ") + self.verbalize_field("quantity", self.quantity, True)).ques

itn/arabic/rules/fraction.py

@@ -0,0 +1,72 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2026 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pynini
+from pynini.lib.pynutil import add_weight, delete, insert
+
+from itn.utils import get_abs_path
+from tn.processor import Processor
+
+
+class Fraction(Processor):
+    """Fractions, e.g. ``واحد و نصف`` -> ``1 1/2`` and ``تسعة أثلاث`` -> ``9/3``.
+
+    A lone singular (``نصف``) or dual (``ثلثين``) fraction noun implies the
+    numerator 1 or 2; plural nouns follow a numerator from 3 to 10; other
+    fractions are spoken ``X على Y``. The tagger keeps the words, dropping
+    only the ``و`` and ``على`` joiners.
+    """
+
+    def __init__(self, cardinal):
+        super().__init__(name="fraction", ordertype="itn")
+        self.cardinal = cardinal
+        number = cardinal.graph
+        singular = pynini.string_file(get_abs_path("arabic/data/number/fraction_singular.tsv"))
+        dual = pynini.string_file(get_abs_path("arabic/data/number/fraction_dual.tsv"))
+        plural = pynini.string_file(get_abs_path("arabic/data/number/fraction_plural.tsv"))
+        three_to_ten = pynini.union(*[str(n) for n in range(3, 11)])
+        self.number = number
+        self.singular = pynini.invert(singular).optimize()
+        self.dual = pynini.invert(dual).optimize()
+        self.plural = pynini.invert(plural).optimize()
+        self.three_to_ten = (number @ three_to_ten).optimize()
+        self.negative = cardinal.negative
+        sign = self.tag_field("negative", self.negative) + self.DELETE_SPACE + insert(" ")
+        self.tagger = self.add_tokens(sign.ques + self.tag_number())
+        sign_out = self.verbalize_field("negative", self.negative) + delete(" ")
+        self.verbalizer = self.delete_tokens(sign_out.ques + self.verbalize_number())
+
+    def tag_number(self):
+        """Raw fraction fields without the sign, shared with measure."""
+
+        optional_space = self.DELETE_ZERO_OR_ONE_SPACE
+        integer = self.tag_field("integer_part", self.number) + optional_space + delete("و") + optional_space
+        integer += insert(" ")
+        lone = self.tag_field("denominator", self.singular | self.dual)
+        plural = self.tag_field("numerator", self.three_to_ten) + optional_space + insert(" ")
+        plural += self.tag_field("denominator", self.plural)
+        ratio = self.tag_field("numerator", self.number) + optional_space + delete("على") + optional_space
+        ratio += insert(" ") + self.tag_field("denominator", self.number)
+        return integer.ques + (lone | plural | add_weight(ratio, 0.001))
+
+    def verbalize_number(self):
+        integer = self.verbalize_field("integer_part", self.number) + pynini.accep(" ")
+        lone = insert("1/") + self.verbalize_field("denominator", self.singular)
+        lone |= insert("2/") + self.verbalize_field("denominator", self.dual)
+        plural = self.verbalize_field("numerator", self.three_to_ten) + insert("/")
+        plural += self.verbalize_field("denominator", self.plural, True)
+        ratio = self.verbalize_field("numerator", self.number) + insert("/")
+        ratio += self.verbalize_field("denominator", self.number, True)
+        return integer.ques + (lone | plural | ratio)

itn/arabic/rules/measure.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2026 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pynini
+from pynini.lib.pynutil import delete
+
+from itn.utils import get_abs_path
+from tn.processor import Processor
+from tn.utils import load_labels
+
+
+class Measure(Processor):
+    """Quantities with units, e.g. ``عشرون في المائة`` -> ``20%``.
+
+    The quantity is a cardinal, decimal or fraction (flat raw fields reusing
+    those rules' graphs) followed by a spoken unit; the unit symbol is
+    attached without a space.
+    """
+
+    def __init__(self, cardinal, decimal, fraction):
+        super().__init__(name="measure", ordertype="itn")
+        names = {}
+        for symbol, name in load_labels(get_abs_path("arabic/data/measure/measurements.tsv")):
+            names.setdefault(name, symbol)
+        self.units = pynini.string_map([(pynini.escape(name), pynini.escape(symbol))
+                                        for name, symbol in names.items()]).optimize()
+        negative = cardinal.negative
+        sign = self.tag_field("negative", negative) + self.DELETE_EXTRA_SPACE
+        quantity = self.tag_field("integer", cardinal.graph) | decimal.tag_number() | fraction.tag_number()
+        units = self.DELETE_EXTRA_SPACE + self.tag_field("units", self.units)
+        self.tagger = self.add_tokens(sign.ques + quantity + units)
+
+        sign = self.verbalize_field("negative", negative) + delete(" ")
+        quantity = self.verbalize_field("integer", cardinal.graph) | decimal.verbalize_number()
+        quantity |= fraction.verbalize_number()
+        units = self.verbalize_field("units", self.units, True)
+        self.verbalizer = self.delete_tokens(sign.ques + quantity + units)

itn/arabic/rules/money.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+# Copyright (c) 2026 Zhendong Peng (pzd17@tsinghua.org.cn)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pynini
+from pynini.lib.pynutil import delete, insert
+
+from itn.utils import get_abs_path
+from tn.processor import Processor
+from tn.utils import load_labels
+
+# The currency symbol is written first: $7.50, د.ك5.
+TOKEN_ORDER = {"money": ["currency", "integer_part", "fractional_part", "currency_min"]}
+
+
+def symbols(*paths):
+    """Maps each spoken currency name to the first symbol listed for it."""
+
+    names = {}
+    for path in paths:
+        for row in load_labels(get_abs_path(path)):
+            names.setdefault(row[1], row[0])
+    return pynini.string_map([(pynini.escape(name), pynini.escape(symbol)) for name, symbol in names.items()])
+
+
+class Money(Processor):
+    """Money, e.g. ``سبعة دولار وخمسون سنت`` -> ``$7.50`` and ``خمسة دينار كويتي`` -> ``د.ك5``.
+
+    The tagger keeps the spoken amount, currency and minor-unit words; the
+    verbalizer writes the currency symbol, digits and two-digit cents.
+    """
+
+    def __init__(self, cardinal):
+        super().__init__(name="money", ordertype="itn", token_orders=TOKEN_ORDER)
+        number = cardinal.graph
+        major = "arabic/data/money/currency_major.tsv"
+        local = "arabic/data/money/local_currency.tsv"
+        # Names listed in both tables (ريال سعودي, درهم إماراتي) take the local symbol.
+        self.currency = symbols(local, major).optimize()
+        major_names = self.input_projection(symbols(major))
+        local_names = self.input_projection(symbols(local))
+        minor = [row[1] for name in ("singular", "plural")
+                 for row in load_labels(get_abs_path("arabic/data/money/currency_minor_{}.tsv".format(name)))]
+        minor_names = pynini.union(*[pynini.escape(name) for name in minor]).optimize()
+        self.cents = (number @ (self.DIGIT**2 | insert("0") + self.DIGIT)).optimize()
+
+        integer = self.tag_field("integer_part", number) + self.DELETE_EXTRA_SPACE
+        cents = self.tag_field("fractional_part", self.cents) + self.DELETE_SPACE + insert(" ")
+        cents += self.tag_field("currency_min", minor_names)
+        joined = self.DELETE_SPACE + delete("و") + self.DELETE_ZERO_OR_ONE_SPACE + insert(" ") + cents
+        graph = integer + self.tag_field("currency", major_names) + joined.ques
+        graph |= integer + self.tag_field("currency", local_names)
+        graph |= cents
+        self.tagger = self.add_tokens(graph)
+
+        currency = self.verbalize_field("currency", self.currency)
+        amount = self.verbalize_field("integer_part", number, True)
+        fractional = insert(".") + self.verbalize_field("fractional_part", self.cents, True)
+        minor_unit = self.verbalize_field("currency_min", delete(minor_names), True)
+        # Cents on their own are dollars, as in the original grammar.
+        alone = insert("$0.") + self.verbalize_field("fractional_part", self.cents) + minor_unit
+        self.verbalizer = self.delete_tokens(currency + amount + (fractional + minor_unit).ques | alone)