[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Signed-off-by: Mai Anh <palasek182@gmail.com>

Author: pre-commit-ci[bot]

nemo_text_processing/text_normalization/pt/__init__.py

@@ -10,4 +10,4 @@
 # 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.
+# limitations under the License.

nemo_text_processing/text_normalization/pt/graph_utils.py

@@ -47,9 +47,7 @@
 
 delete_space = pynutil.delete(pynini.closure(NEMO_WHITE_SPACE))
 insert_space = pynutil.insert(" ")
-delete_extra_space = pynini.cross(
-    pynini.closure(NEMO_WHITE_SPACE, 1), " "
-).optimize()
+delete_extra_space = pynini.cross(pynini.closure(NEMO_WHITE_SPACE, 1), " ").optimize()
 
 
 def generator_main(file_name: str, graphs: Dict[str, "pynini.FstLike"]) -> None:
@@ -84,13 +82,9 @@ def __init__(self, name: str, kind: str, deterministic: bool = True):
         self._fst = None
         self.deterministic = deterministic
 
-        self.far_path = Path(
-            os.path.dirname(os.path.abspath(__file__)) + "/grammars/" + kind + "/" + name + ".far"
-        )
+        self.far_path = Path(os.path.dirname(os.path.abspath(__file__)) + "/grammars/" + kind + "/" + name + ".far")
         if self.far_exist():
-            self._fst = Far(
-                self.far_path, mode="r", arc_type="standard", far_type="default"
-            ).get_fst()
+            self._fst = Far(self.far_path, mode="r", arc_type="standard", far_type="default").get_fst()
 
     def far_exist(self) -> bool:
         return self.far_path.exists()
@@ -116,9 +110,7 @@ def delete_tokens(self, fst) -> "pynini.FstLike":
             + delete_space
             + pynutil.delete("}")
         )
-        return res @ pynini.cdrewrite(
-            pynini.cross("\u00a0", " "), "", "", NEMO_SIGMA
-        )
+        return res @ pynini.cdrewrite(pynini.cross("\u00a0", " "), "", "", NEMO_SIGMA)
 
 
 # ---- PT-specific (Brazilian: 1.000.000 or 1 000 000) ----
@@ -172,9 +164,7 @@ def shift_cardinal_gender_pt(fst: "pynini.FstLike") -> "pynini.FstLike":
     )
     fem_hundreds = pynini.cdrewrite(
         pynini.cross("entos", "entas"),
-        pynini.union(
-            "duz", "trez", "quatroc", "quinh", "seisc", "setec", "oitoc", "novec"
-        ),
+        pynini.union("duz", "trez", "quatroc", "quinh", "seisc", "setec", "oitoc", "novec"),
         pynini.union(NEMO_SPACE, pynini.accep("[EOS]"), pynini.accep('"')),
         NEMO_SIGMA,
     )

nemo_text_processing/text_normalization/pt/taggers/cardinal.py

@@ -26,8 +26,8 @@
     NEMO_WHITE_SPACE,
     GraphFst,
     delete_space,
-    insert_space,
     filter_cardinal_punctuation,
+    insert_space,
 )
 from nemo_text_processing.text_normalization.pt.utils import get_abs_path, load_labels
 
@@ -48,33 +48,29 @@ def __init__(self, deterministic: bool = True):
         super().__init__(name="cardinal", kind="classify", deterministic=deterministic)
 
         specials = {
-            row[0]: row[1]
-            for row in load_labels(get_abs_path("data/numbers/cardinal_specials.tsv"))
-            if len(row) >= 2
+            row[0]: row[1] for row in load_labels(get_abs_path("data/numbers/cardinal_specials.tsv")) if len(row) >= 2
         }
         connector_e = insert_space + pynutil.insert(specials["connector"]) + insert_space
         thousand = specials["thousand"]
         hundred_100 = specials["hundred_100"]
         hundred_1 = specials["hundred_1"]
 
         scale_rows = load_labels(get_abs_path("data/numbers/scales.tsv"))
-        scales = [
-            (row[0], row[1], int(row[2]))
-            for row in scale_rows
-            if len(row) >= 3 and row[2].strip().isdigit()
-        ]
+        scales = [(row[0], row[1], int(row[2])) for row in scale_rows if len(row) >= 3 and row[2].strip().isdigit()]
 
         _num = lambda p: pynini.string_file(get_abs_path(f"data/numbers/{p}"))
         zero, digit, teens, tens, hundreds = (
-            _num("zero.tsv"), _num("digit.tsv"), _num("teens.tsv"), _num("tens.tsv"), _num("hundreds.tsv")
+            _num("zero.tsv"),
+            _num("digit.tsv"),
+            _num("teens.tsv"),
+            _num("tens.tsv"),
+            _num("hundreds.tsv"),
         )
         digits_no_one = (NEMO_DIGIT - "1") @ digit
 
         graph_tens = teens | (tens + (pynutil.delete("0") | (connector_e + digit)))
         self.tens = graph_tens.optimize()
-        self.two_digit_non_zero = pynini.union(
-            digit, graph_tens, (pynini.cross("0", NEMO_SPACE) + digit)
-        ).optimize()
+        self.two_digit_non_zero = pynini.union(digit, graph_tens, (pynini.cross("0", NEMO_SPACE) + digit)).optimize()
 
         graph_hundreds = hundreds + pynini.union(
             pynutil.delete("00"),
@@ -109,7 +105,8 @@ def __init__(self, deterministic: bool = True):
                 (connector_e + graph_tens),
                 (connector_e + pynutil.delete("0") + digit),
             ),
-            hundreds + pynini.union(
+            hundreds
+            + pynini.union(
                 (connector_e + graph_tens),
                 (connector_e + digit),
             ),
@@ -129,7 +126,9 @@ def __init__(self, deterministic: bool = True):
         )
         t_comp_no_one = pynini.union(
             pynutil.delete("000") + h_comp_no_one,
-            h_comp_no_one + insert_space + pynutil.insert(thousand)
+            h_comp_no_one
+            + insert_space
+            + pynutil.insert(thousand)
             + ((insert_space + h_comp) | pynutil.delete("000")),
             pynini.cross("001", thousand) + ((insert_space + h_comp) | pynutil.delete("000")),
         )
@@ -154,8 +153,10 @@ def __init__(self, deterministic: bool = True):
         # Units 6 (u6): pure get "e" after scale; compound no "e"
         u6_one = pynini.cross("000001", "1") @ digit
         u6_pure = pynini.union(
-            u6_one, pynini.cross("001000", thousand),
-            pynini.cross("000010", "10") @ graph_tens, pynini.cross("000100", hundred_100),
+            u6_one,
+            pynini.cross("001000", thousand),
+            pynini.cross("000010", "10") @ graph_tens,
+            pynini.cross("000100", hundred_100),
             (pynini.cross("010000", "10") @ graph_tens) + insert_space + pynutil.insert(thousand),
             pynini.cross("100000", hundred_100) + insert_space + pynutil.insert(thousand),
         )
@@ -164,36 +165,40 @@ def __init__(self, deterministic: bool = True):
         z18 = pynini.accep("0" * 18)  # 18 zeros: branch no "e"
         smaller_e = (connector_e + u6_pure) | u6_compound | pynutil.delete("0" * 6)
         smaller = u6 | pynutil.delete("0" * 6)
-        graph_24 = (
-            ((NEMO_DIGIT**18 - z18) + NEMO_DIGIT**6) @ (graph_large_scales + smaller_e)
-        ) | ((z18 + NEMO_DIGIT**6) @ (pynutil.delete(z18) + smaller))
+        graph_24 = (((NEMO_DIGIT**18 - z18) + NEMO_DIGIT**6) @ (graph_large_scales + smaller_e)) | (
+            (z18 + NEMO_DIGIT**6) @ (pynutil.delete(z18) + smaller)
+        )
 
         trail_by_z = {9: trail_9, 12: trail_12}
         magnitude_patterns = [
             self._build_magnitude_pattern(
-                one_label, plural_suffix, magnitude_zeros, trail_by_z.get(magnitude_zeros),
-                connector_e, insert_space, digit, graph_tens, graph_hundreds,
+                one_label,
+                plural_suffix,
+                magnitude_zeros,
+                trail_by_z.get(magnitude_zeros),
+                connector_e,
+                insert_space,
+                digit,
+                graph_tens,
+                graph_hundreds,
             )
             for one_label, plural_suffix, magnitude_zeros in scales
             if magnitude_zeros > 0
         ]
 
         pad = (NEMO_DIGIT - "0") + pynini.closure(NEMO_DIGIT, 0)
         pad = pad @ pynini.cdrewrite(pynini.closure(pynutil.insert("0")), "[BOS]", "", NEMO_SIGMA) @ NEMO_DIGIT**24
-        norm = pynini.cdrewrite(delete_space, "[BOS]", "", NEMO_SIGMA) @ pynini.cdrewrite(delete_space, "", "[EOS]", NEMO_SIGMA)
-        norm = norm @ pynini.cdrewrite(pynini.cross(pynini.closure(NEMO_WHITE_SPACE, 2), NEMO_SPACE), NEMO_ALPHA, NEMO_ALPHA, NEMO_SIGMA)
+        norm = pynini.cdrewrite(delete_space, "[BOS]", "", NEMO_SIGMA) @ pynini.cdrewrite(
+            delete_space, "", "[EOS]", NEMO_SIGMA
+        )
+        norm = norm @ pynini.cdrewrite(
+            pynini.cross(pynini.closure(NEMO_WHITE_SPACE, 2), NEMO_SPACE), NEMO_ALPHA, NEMO_ALPHA, NEMO_SIGMA
+        )
         self.graph = reduce(lambda a, b: a | b, magnitude_patterns, pad @ graph_24 @ norm) | zero
         self.graph = filter_cardinal_punctuation(self.graph).optimize()
 
-        optional_minus_graph = pynini.closure(
-            pynutil.insert("negative: ") + pynini.cross("-", "\"true\" "), 0, 1
-        )
-        final_graph = (
-            optional_minus_graph
-            + pynutil.insert("integer: \"")
-            + self.graph
-            + pynutil.insert("\"")
-        )
+        optional_minus_graph = pynini.closure(pynutil.insert("negative: ") + pynini.cross("-", "\"true\" "), 0, 1)
+        final_graph = optional_minus_graph + pynutil.insert("integer: \"") + self.graph + pynutil.insert("\"")
         final_graph = self.add_tokens(final_graph)
         self.fst = final_graph.optimize()
 
@@ -221,13 +226,19 @@ def _build_scale_trailing_graph(self, scale_3, sub_graph, trailing_len, total_le
     @staticmethod
     def _pure_inputs(num_digits):
         """Inputs 1, 10, 100, ... as num_digits-digit strings."""
-        return pynini.union(
-            *[pynini.accep(str(10**k).zfill(num_digits)) for k in range(0, num_digits)]
-        )
+        return pynini.union(*[pynini.accep(str(10**k).zfill(num_digits)) for k in range(0, num_digits)])
 
     def _magnitude_graph(
-        self, one_word, plural_suffix, zero_count, graph_digit, graph_tens, graph_hundreds,
-        connector_e, insert_space, trailing_pair=None,
+        self,
+        one_word,
+        plural_suffix,
+        zero_count,
+        graph_digit,
+        graph_tens,
+        graph_hundreds,
+        connector_e,
+        insert_space,
+        trailing_pair=None,
     ):
         """Round (1–3 digit + scale + zeros); optional trailing (e + pure | space + compound)."""
         zeros = "0" * zero_count
@@ -236,54 +247,51 @@ def _magnitude_graph(
         for L in (1, 2, 3):
             total = zero_count + L
             if L == 1:
-                lead = pynini.cross("1", one_word) | (
-                    (NEMO_DIGIT - "1") @ graph_digit + pynutil.insert(plural_suffix)
-                )
+                lead = pynini.cross("1", one_word) | ((NEMO_DIGIT - "1") @ graph_digit + pynutil.insert(plural_suffix))
             else:
-                lead = (
-                    pynini.closure(NEMO_DIGIT, L, L)
-                    @ (graph_tens if L == 2 else graph_hundreds)
-                    + pynutil.insert(plural_suffix)
+                lead = pynini.closure(NEMO_DIGIT, L, L) @ (graph_tens if L == 2 else graph_hundreds) + pynutil.insert(
+                    plural_suffix
                 )
             lead_fst = NEMO_DIGIT**L @ lead
-            round_pats.append(
-                pynini.closure(NEMO_DIGIT, total, total) @ (lead_fst + pynutil.delete(zeros))
-            )
+            round_pats.append(pynini.closure(NEMO_DIGIT, total, total) @ (lead_fst + pynutil.delete(zeros)))
             if trailing_pair:
                 pure, compound = trailing_pair
-                trail_part = (
-                    NEMO_DIGIT**zero_count @ (connector_e + pure)
-                    | NEMO_DIGIT**zero_count @ (insert_space + compound)
-                )
-                trail_pats.append(
-                    pynini.closure(NEMO_DIGIT, total, total) @ (lead_fst + trail_part)
+                trail_part = NEMO_DIGIT**zero_count @ (connector_e + pure) | NEMO_DIGIT**zero_count @ (
+                    insert_space + compound
                 )
+                trail_pats.append(pynini.closure(NEMO_DIGIT, total, total) @ (lead_fst + trail_part))
         graph_round = pynini.union(*round_pats)
         graph_trail = pynini.union(*trail_pats) if trail_pats else None
         return graph_round, graph_trail
 
     def _build_magnitude_pattern(
         self,
-        one_label, plural_suffix, magnitude_zeros,
+        one_label,
+        plural_suffix,
+        magnitude_zeros,
         trailing_pair,
-        connector_e, insert_space,
-        graph_digit, graph_tens, graph_hundreds,
+        connector_e,
+        insert_space,
+        graph_digit,
+        graph_tens,
+        graph_hundreds,
     ):
         """Restrict length; round + optional non-zero trailing."""
-        restrict = (NEMO_DIGIT - "0") + pynini.closure(
-            NEMO_DIGIT, magnitude_zeros, magnitude_zeros + 2
-        )
+        restrict = (NEMO_DIGIT - "0") + pynini.closure(NEMO_DIGIT, magnitude_zeros, magnitude_zeros + 2)
         graph_round, graph_trail = self._magnitude_graph(
-            one_label, plural_suffix, magnitude_zeros,
-            graph_digit, graph_tens, graph_hundreds,
-            connector_e, insert_space, trailing_pair,
+            one_label,
+            plural_suffix,
+            magnitude_zeros,
+            graph_digit,
+            graph_tens,
+            graph_hundreds,
+            connector_e,
+            insert_space,
+            trailing_pair,
         )
         if graph_trail is None:
             return pynutil.add_weight(restrict @ graph_round, -1.0)
         non_zero_trail = pynini.union(
-            *[
-                NEMO_DIGIT**n + (NEMO_DIGIT**magnitude_zeros - pynini.accep("0" * magnitude_zeros))
-                for n in (1, 2, 3)
-            ]
+            *[NEMO_DIGIT**n + (NEMO_DIGIT**magnitude_zeros - pynini.accep("0" * magnitude_zeros)) for n in (1, 2, 3)]
         )
         return pynutil.add_weight(restrict @ (graph_round | (non_zero_trail @ graph_trail)), -1.0)