py_function_lib_(ABSL_DIE_IF_NULL(py_function_lib)),  // Crash OK
      src_saved_model_path_(src_saved_model_path),
      function_aliases_(std::move(function_aliases)),
      tags_(std::move(tags)),
      signature_def_map_(std::move(signature_def_map)),
      signature_keys_(std::move(signature_keys)) {}

absl::Status CalibrationComponent::ExportToSavedModel(
    ModuleOp module_op, absl::string_view calibration_data_dir,

  std::string src_saved_model_path_;

  // Function alias mapping for pre-calibrated SavedModel. Used to preserve
  // aliased functions.
  absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases_;

  // Tags to identify the MetaGraphDef to load from a SavedModel.
  const std::unordered_set<std::string> tags_;

  const absl::flat_hash_map<std::string, tensorflow::SignatureDef>
      signature_def_map_;

      CreateMlirContextForQuantization();

  absl::StatusOr<absl::flat_hash_map<FunctionName, FunctionAlias>>
      function_aliases = GetFunctionAliases(saved_model_path, tags);
  if (!function_aliases.ok()) {
    return absl::InternalError(absl::StrCat(
        "Failed to get function alias: ", function_aliases.status().message()));
  }

  absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> module =

    std::unordered_set<std::string> tag_set(tag_names.begin(), tag_names.end());
    TF_ASSIGN_OR_RETURN(
        auto function_aliases,
        quant::stablehlo::GetFunctionAliases(input_path, tag_set));
    quant::stablehlo::UpdateFunctionAliases(function_aliases, *module_op);
    absl::c_for_each(function_aliases, [&](const auto& aliases) {
      return aliased_function_names.insert(aliases.first);
    });
  }

    meta_graph_def = output_loader.get_meta_graph_def_from_tags(tags)
    function_aliases = meta_graph_def.meta_info_def.function_aliases
    self.assertNotEmpty(function_aliases)
    self.assertCountEqual(function_aliases.values(), {'conv_func'})

    # Test that the aliased function contains a quantized op.
    for func_name, alias in function_aliases.items():
      if alias == 'conv_func':

    """Gets the function aliases in the output saved model."""
    loader = loader_impl.SavedModelLoader(output_saved_model_path)
    return loader.get_meta_graph_def_from_tags(
        tags
    ).meta_info_def.function_aliases

  def _create_matmul_model(
      self,
      input_shape: Sequence[int],
      weight_shape: Sequence[int],
      saved_model_path: str,
      bias_fn: Optional[ops.Operation] = None,

      signature_def_map,
      tags,
      init_op_name=exported_model.init_node_name,
      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)