TF_ASSERT_OK_AND_ASSIGN(const std::optional<SaverDef> saver_def,
                          CreateSaverDef(control_ret_node_names, graph_def));
  ASSERT_NE(saver_def, std::nullopt);
  EXPECT_THAT(saver_def->version(), SaverDef::V2);
  EXPECT_THAT(saver_def->restore_op_name(), "restore_op_0");
  EXPECT_THAT(saver_def->filename_tensor_name(), "foo:0");
  EXPECT_THAT(saver_def->save_tensor_name(), "tf_quant__save_op_0:0");
}

  } else if (absl::c_none_of(fields, is_empty_predicate)) {
    SaverDef saver_def{};
    saver_def.set_version(SaverDef::V2);
    saver_def.set_filename_tensor_name(filename_tensor_name);
    saver_def.set_restore_op_name(restore_op_name);
    // :0 attached to indicate the first result tensor. This saves the model
    // checkpoint when fetched.
    saver_def.set_save_tensor_name(absl::StrCat(save_node_name, ":0"));
    return saver_def;

          saved_model_constants.ASSETS_KEY,
          asset_any_proto,
      )

    model_saver = None
    # If `saver_def` is not None, it means there are variables in the graph.
    if saver_def:
      model_saver = saver.Saver(saver_def=saver_def)
      logging.info('Saver created with SaverDef: %s', saver_def)

      # Variables should be restored once before exporting as saved model

  // should be fed.
  repeated AssetFileDef asset_file_defs = 8;

  // SaverDef including the information required for saving and restoring
  // variables. This field is not set if there are no variables in the exported
  // graph. If set, the fields `version`, `filename_tensor_name`,
  // `restore_op_name` and `save_tensor_name` are populated.
  SaverDef saver_def = 10;

) -> Optional[saver_pb2.SaverDef]:
  """Returns the SaverDef from ExportedModel, None otherwise.

  Args:
    exported_model: ExportedModel to take the SaverDef from.

  Returns:
    SaverDef instance if the field `saver_def` is set. None otherwise.
  """
  if exported_model.HasField('saver_def'):
    return exported_model.saver_def
  return None

    absl::string_view checkpoint_dir,
    std::optional<tensorflow::SaverDef> saver_def,
    const absl::flat_hash_map<std::string, std::string>& function_aliases,
    const std::vector<tensorflow::AssetFileDef>& asset_file_defs);

// Creates a new `SaverDef` instance, which contains information regarding
// checkpoint saving and restoring. This function returns a `SaverDef` instance
// with four fields populated: `version`, `filename_tensor_name`,

  if (meta_graph.has_saver_def()) {
    TF_RETURN_IF_ERROR(RunRestore(run_options, export_dir,
                                  meta_graph.saver_def().restore_op_name(),
                                  meta_graph.saver_def().filename_tensor_name(),
                                  asset_file_defs, session->get()));
  }
  // Record walltime spent in restoring graph from disk, but postpone metric

    }
    node {
      name: "save/restore_all"
      op: "NoOp"
      input: "^save/restore_shard"
    }
    versions {
      producer: 23
    }
  }
  saver_def {
    filename_tensor_name: "save/Const:0"
    save_tensor_name: "save/Identity:0"
    restore_op_name: "save/restore_all"
    max_to_keep: 5
    sharded: true
    keep_checkpoint_every_n_hours: 10000.0

    variable_and_assets.push_back(
        {input_.meta_graph_def().saver_def().filename_tensor_name(),
         variable_filename_op});
    variable_and_assets.insert(variable_and_assets.end(), assets.begin(),
                               assets.end());

    const auto& restore_op_name =
        input_.meta_graph_def().saver_def().restore_op_name();

#include "tensorflow/core/platform/test.h"

tensorflow::ServerDef GetServerDef(const std::string& job_name, int num_tasks) {
  tensorflow::ServerDef server_def;
  server_def.set_protocol("grpc");
  server_def.set_job_name(job_name);
  server_def.set_task_index(0);
  tensorflow::ClusterDef* cluster_def = server_def.mutable_cluster();
  tensorflow::JobDef* job_def = cluster_def->add_job();
  job_def->set_name(job_name);
  for (int i = 0; i < num_tasks; i++) {