clang-format | Format fbsource with clang-format 21.

Reviewed By: ChristianK275

Differential Revision: D85317706

fbshipit-source-id: b399c5c4b75252999442b7d7d2778e7a241b0025

Author: nlutsenko

bindings/python/flashlight/lib/text/_decoder.cpp

@@ -234,38 +234,39 @@ PYBIND11_MODULE(flashlight_lib_text_decoder, m) {
       .def_readwrite("sil_score", &LexiconDecoderOptions::silScore)
       .def_readwrite("log_add", &LexiconDecoderOptions::logAdd)
       .def_readwrite("criterion_type", &LexiconDecoderOptions::criterionType)
-      .def(py::pickle(
-          [](const LexiconDecoderOptions& p) { // __getstate__
-            return py::make_tuple(
-                p.beamSize,
-                p.beamSizeToken,
-                p.beamThreshold,
-                p.lmWeight,
-                p.wordScore,
-                p.unkScore,
-                p.silScore,
-                p.logAdd,
-                p.criterionType);
-          },
-          [](py::tuple t) { // __setstate__
-            if (t.size() != 9) {
-              throw std::runtime_error(
-                  "Cannot run __setstate__ on LexiconDecoderOptions - "
-                  "insufficient arguments provided.");
-            }
-            LexiconDecoderOptions opts = {
-                t[0].cast<int>(), // beamSize
-                t[1].cast<int>(), // beamSizeToken
-                t[2].cast<double>(), // beamThreshold
-                t[3].cast<double>(), // lmWeight
-                t[4].cast<double>(), // wordScore
-                t[5].cast<double>(), // unkScore
-                t[6].cast<double>(), // silScore
-                t[7].cast<bool>(), // logAdd
-                t[8].cast<CriterionType>() // criterionType
-            };
-            return opts;
-          }));
+      .def(
+          py::pickle(
+              [](const LexiconDecoderOptions& p) { // __getstate__
+                return py::make_tuple(
+                    p.beamSize,
+                    p.beamSizeToken,
+                    p.beamThreshold,
+                    p.lmWeight,
+                    p.wordScore,
+                    p.unkScore,
+                    p.silScore,
+                    p.logAdd,
+                    p.criterionType);
+              },
+              [](py::tuple t) { // __setstate__
+                if (t.size() != 9) {
+                  throw std::runtime_error(
+                      "Cannot run __setstate__ on LexiconDecoderOptions - "
+                      "insufficient arguments provided.");
+                }
+                LexiconDecoderOptions opts = {
+                    t[0].cast<int>(), // beamSize
+                    t[1].cast<int>(), // beamSizeToken
+                    t[2].cast<double>(), // beamThreshold
+                    t[3].cast<double>(), // lmWeight
+                    t[4].cast<double>(), // wordScore
+                    t[5].cast<double>(), // unkScore
+                    t[6].cast<double>(), // silScore
+                    t[7].cast<bool>(), // logAdd
+                    t[8].cast<CriterionType>() // criterionType
+                };
+                return opts;
+              }));
 
   py::class_<LexiconFreeDecoderOptions>(m, "LexiconFreeDecoderOptions")
       .def(
@@ -294,34 +295,35 @@ PYBIND11_MODULE(flashlight_lib_text_decoder, m) {
       .def_readwrite("log_add", &LexiconFreeDecoderOptions::logAdd)
       .def_readwrite(
           "criterion_type", &LexiconFreeDecoderOptions::criterionType)
-      .def(py::pickle(
-          [](const LexiconFreeDecoderOptions& p) { // __getstate__
-            return py::make_tuple(
-                p.beamSize,
-                p.beamSizeToken,
-                p.beamThreshold,
-                p.lmWeight,
-                p.silScore,
-                p.logAdd,
-                p.criterionType);
-          },
-          [](py::tuple t) { // __setstate__
-            if (t.size() != 7) {
-              throw std::runtime_error(
-                  "Cannot run __setstate__ on LexiconFreeDecoderOptions - "
-                  "insufficient arguments provided.");
-            }
-            LexiconFreeDecoderOptions opts = {
-                t[0].cast<int>(), // beamSize
-                t[1].cast<int>(), // beamSizeToken
-                t[2].cast<double>(), // beamThreshold
-                t[3].cast<double>(), // lmWeight
-                t[4].cast<double>(), // silScore
-                t[5].cast<bool>(), // logAdd
-                t[6].cast<CriterionType>() // criterionType
-            };
-            return opts;
-          }));
+      .def(
+          py::pickle(
+              [](const LexiconFreeDecoderOptions& p) { // __getstate__
+                return py::make_tuple(
+                    p.beamSize,
+                    p.beamSizeToken,
+                    p.beamThreshold,
+                    p.lmWeight,
+                    p.silScore,
+                    p.logAdd,
+                    p.criterionType);
+              },
+              [](py::tuple t) { // __setstate__
+                if (t.size() != 7) {
+                  throw std::runtime_error(
+                      "Cannot run __setstate__ on LexiconFreeDecoderOptions - "
+                      "insufficient arguments provided.");
+                }
+                LexiconFreeDecoderOptions opts = {
+                    t[0].cast<int>(), // beamSize
+                    t[1].cast<int>(), // beamSizeToken
+                    t[2].cast<double>(), // beamThreshold
+                    t[3].cast<double>(), // lmWeight
+                    t[4].cast<double>(), // silScore
+                    t[5].cast<bool>(), // logAdd
+                    t[6].cast<CriterionType>() // criterionType
+                };
+                return opts;
+              }));
 
   py::class_<DecodeResult>(m, "DecodeResult")
       .def(py::init<int>(), "length"_a)
@@ -404,38 +406,39 @@ PYBIND11_MODULE(flashlight_lib_text_decoder, m) {
       .def(
           "get_options",
           &LexiconFreeDecoder::getOptions)
-      .def(py::pickle(
-          [](const LexiconFreeDecoder& p) { // __getstate__
-            if (p.getAllFinalHypothesis().size() != 0) {
-              throw std::runtime_error(
-                  "LexiconFreeDecoder: cannot pickle decoder that has state");
-            }
-            if (!std::dynamic_pointer_cast<ZeroLM>(p.getLMPtr())) {
-              throw std::runtime_error(
-                  "LexiconFreeDecoder: cannot pickle a decoder with an "
-                  "integrated language model that is not ZeroLM");
-            }
-            return py::make_tuple(
-                p.getOptions(),
-                p.getSilIdx(),
-                p.getBlankIdx(),
-                p.getTransitions());
-          },
-          [](py::tuple t) { // __setstate__
-            if (t.size() != 4) {
-              throw std::runtime_error(
-                  "Cannot run __setstate__ on LexiconFreeDecoder - "
-                  "insufficient arguments provided.");
-            }
-
-            return LexiconFreeDecoder(
-                t[0].cast<LexiconFreeDecoderOptions>(), // options
-                std::make_shared<ZeroLM>(), // lm
-                t[1].cast<int>(), // silIdx
-                t[2].cast<int>(), // blankIdx
-                t[3].cast<std::vector<float>>() // transitions
-            );
-          }));
+      .def(
+          py::pickle(
+              [](const LexiconFreeDecoder& p) { // __getstate__
+                if (p.getAllFinalHypothesis().size() != 0) {
+                  throw std::runtime_error(
+                      "LexiconFreeDecoder: cannot pickle decoder that has state");
+                }
+                if (!std::dynamic_pointer_cast<ZeroLM>(p.getLMPtr())) {
+                  throw std::runtime_error(
+                      "LexiconFreeDecoder: cannot pickle a decoder with an "
+                      "integrated language model that is not ZeroLM");
+                }
+                return py::make_tuple(
+                    p.getOptions(),
+                    p.getSilIdx(),
+                    p.getBlankIdx(),
+                    p.getTransitions());
+              },
+              [](py::tuple t) { // __setstate__
+                if (t.size() != 4) {
+                  throw std::runtime_error(
+                      "Cannot run __setstate__ on LexiconFreeDecoder - "
+                      "insufficient arguments provided.");
+                }
+
+                return LexiconFreeDecoder(
+                    t[0].cast<LexiconFreeDecoderOptions>(), // options
+                    std::make_shared<ZeroLM>(), // lm
+                    t[1].cast<int>(), // silIdx
+                    t[2].cast<int>(), // blankIdx
+                    t[3].cast<std::vector<float>>() // transitions
+                );
+              }));
 
   // Seq2seq Decoding
   py::class_<LexiconSeq2SeqDecoderOptions>(m, "LexiconSeq2SeqDecoderOptions")