const std::vector<std::string>& signature_keys,
         const absl::flat_hash_map<std::string, SignatureDef>&
             signature_def_map,
         const PyFunctionLibrary& py_function_library) -> absl::Status {
        // LINT.ThenChange(pywrap_quantize_model.pyi:quantize_qat_model)
        std::unordered_set<std::string> tags;
        tags.insert(quantization_options.tags().begin(),

    TF_ASSIGN_OR_RETURN(std::string calibration_saved_model_dir,
                        CreateTmpDir());
    py_function_library.SaveExportedModel(
        calibration_saved_model_dir, calibration_exported_model,
        saved_model_path, tags, signature_def_map);

    py_function_library.RunCalibration(
        calibration_saved_model_dir, signature_keys, tags,
        quantization_options.force_graph_mode_calibration(),

      signature_keys=list(quant_opts.signature_keys),
      signature_def_map_serialized=_serialize_signature_def_map(
          signature_def_map
      ),
      py_function_library=py_function_lib.PyFunctionLibrary(),
  )


def _run_static_range_ptq(
    src_saved_model_path: str,
    dst_saved_model_path: str,
    quant_opts: _QuantizationOptions,

  # comments in `NotNoneT`.
  return True


class PyFunctionLibrary(pywrap_function_lib.PyFunctionLibrary):
  """Wrapper class for overridden python method definitions.

  This class contains python methods that overrides C++ virtual functions
  declared in `pywrap_function_lib.PyFunctionLibrary`.
  """

  # LINT.IfChange(save_exported_model)
  def save_exported_model(
      self,

#include "tensorflow/lite/toco/toco_flags.pb.h"
#include "tensorflow/lite/toco/types.pb.h"
#include "tsl/platform/errors.h"
#include "tsl/platform/statusor.h"

namespace tensorflow {

using tensorflow::quantization::PyFunctionLibrary;

Status HandleInputOutputArraysWithModule(
    const toco::ModelFlags& model_flags,
    mlir::OwningOpRef<mlir::ModuleOp>* module) {
  mlir::func::FuncOp entry_function = nullptr;

namespace tensorflow {
namespace {

using mlir::MLIRContext;
using mlir::ModuleOp;
using mlir::Operation;
using mlir::OwningOpRef;
using ::stablehlo::quantization::QuantizationConfig;
using ::tensorflow::quantization::PyFunctionLibrary;

bool IsControlFlowV1Op(Operation* op) {
  return mlir::isa<mlir::tf_executor::SwitchOp, mlir::tf_executor::MergeOp,
                   mlir::tf_executor::EnterOp, mlir::tf_executor::ExitOp,

#include "tsl/platform/errors.h"
#include "tsl/platform/protobuf.h"  // IWYU pragma: keep
#include "tsl/platform/statusor.h"

namespace tensorflow {
namespace internal {
namespace {

using ::tensorflow::quantization::PyFunctionLibrary;
using ::tflite::optimize::ReducedPrecisionSupport;

// Op def string for TFLite_Detection_PostProcess Op.
constexpr mlir::StringRef kDetectionPostProcessOp =

                  PyObject* input_contents_txt_raw, bool extended_return,
                  PyObject* debug_info_txt_raw, bool enable_mlir_converter,
                  const tensorflow::quantization::PyFunctionLibrary*
                      quantization_py_function_library) {
  // Use Python C API to validate and convert arguments. In py3 (bytes),
  // in py2 (str).
  auto ConvertArg = [&](PyObject* obj, bool* error) {