}
    }
  )mlir");
  ASSERT_TRUE(module_op);

  AssetFileDef asset_file_def{};
  ASSERT_TRUE(
      TextFormat::ParseFromString(R"pb(filename: "vocab_file.txt",
                                       tensor_info { name: "arg_0:0" })pb",
                                  &asset_file_def));
  const std::vector<AssetFileDef> asset_file_defs = {asset_file_def};

  const absl::StatusOr<ExportedModel> exported_model =

  exported_model.mutable_function_aliases()->insert(function_aliases.begin(),
                                                    function_aliases.end());

  for (const AssetFileDef& asset_file_def : asset_file_defs) {
    *exported_model.mutable_asset_file_defs()->Add() = asset_file_def;
  }

  if (saver_def != std::nullopt) {
    *exported_model.mutable_saver_def() = *std::move(saver_def);
  }

  return exported_model;
}

        signature_def_map, ops.get_default_graph()
    )

    # Add `AssetFileDef`s to the collection so that correct values are fed to
    # the tensors that accept asset file paths.
    for asset_file_def in asset_file_defs:
      asset_any_proto = Any()
      asset_any_proto.Pack(asset_file_def)
      ops.add_to_collection(
          saved_model_constants.ASSETS_KEY,
          asset_any_proto,

                              const std::vector<AssetFileDef>& asset_file_defs,
                              std::vector<std::pair<string, Tensor>>* inputs) {
  if (asset_file_defs.empty()) {
    return;
  }
  for (auto& asset_file_def : asset_file_defs) {
    Tensor assets_file_path_tensor = CreateStringTensor(io::JoinPath(
        export_dir, kSavedModelAssetsDirectory, asset_file_def.filename()));
    inputs->push_back(

  TF_ASSIGN_OR_RETURN(const llvm::SmallVector<AssetFileDef> asset_file_defs,
                      RunExportPasses(export_opts, *ctx, module_op));

  return ConvertMlirModuleToExportedModel(
      module_op, checkpoint_dir, function_aliases,
      {asset_file_defs.begin(), asset_file_defs.end()});
}

absl::StatusOr<ExportedModel> ExportCalibrationModel(

                      absl::Span<const AssetFileDef> assets,
                      std::unique_ptr<Asset>* output) {
  int asset_index = asset.asset_file_def_index();
  if (asset_index >= assets.size()) {
    return errors::FailedPrecondition(
        "SavedAsset contained asset index ", asset_index,
        " but AssetFileDef only contains ", assets.size(), " # of assets");
  }

      saver_def=_get_saver_def_or_none(exported_model),
      checkpoint_dir=exported_model.checkpoint_dir,
      function_aliases=exported_model.function_aliases,
      asset_file_defs=exported_model.asset_file_defs,
  )

  _copy_assets(src_saved_model_path, dst_saved_model_path)

  # Dummy value to indicate successful run, as `None` would indicate error. See
  # comments in `NotNoneT`.
  return True

      }
    }
  }
  collection_def {
    key: "saved_model_assets"
    value {
      any_list {
        value {
          type_url: "type.googleapis.com/tensorflow.AssetFileDef"
          value: "\n\t\n\007Const:0\022\007foo.txt"
        }
      }
    }
  }
  collection_def {
    key: "trainable_variables"
    value {
      bytes_list {