Invalid model_path.
      Targets are not specified.
      Invalid output_path.
  """
  if not model_path:
    raise ValueError("Invalid model_path.")

  if not targets:
    raise ValueError("Targets are not specified.")

  if not output_path:
    raise ValueError("Invalid output_path.")

  return GenerateOneFile(cpp::RendererContext::kSource);
}

string CppGenerator::HeaderFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.h");
}

string CppGenerator::SourceFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.cc");
}

void CppGenerator::WriteHeaderFile() const {
  controller_.WriteFile(HeaderFileName(), HeaderFileContents());
}

      elem.tail = indent_str


def create_xml_file(result_store_dict: ResultDictType,
                    output_path: str,
                    verbose: bool = False):
  """Creates a JUnit-based XML file, with each invocation as a testcase."""
  os.makedirs(os.path.dirname(output_path), exist_ok=True)
  failure_count = 0
  error_count = 0

  date_time = datetime.datetime

  def _create_and_save_vocab_table_lookup_model_tf1(
      self,
      output_path: str,
      tags: Collection[str],
      signature_def_key: str,
  ) -> Tuple[Mapping[str, core.Tensor], Mapping[str, core.Tensor]]:
    """Creates and saves a simple model that uses a vocab table.

    Args:
      output_path: Path to the directory to save the created model.

#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_PATH_CONFIG_H_

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

namespace tensorflow {
namespace generator {

struct PathConfig {
  string output_path;
  std::vector<string> op_names;
  std::vector<string> api_dirs;
  string tf_prefix_dir;
  string tf_root_dir;
  string tf_output_dir;

  explicit PathConfig() = default;

opt<std::string> input_model(llvm::cl::Positional,
                             llvm::cl::desc("<input model path>"),
                             llvm::cl::Required);

// NOLINTNEXTLINE
opt<std::string> output_path("o", llvm::cl::desc("<output path>"),
                             llvm::cl::Required);

// NOLINTNEXTLINE
opt<std::string> export_type("export-type", llvm::cl::desc("<export type>"),

namespace generator {

PathConfig::PathConfig(const string& output_dir, const string& source_dir,
                       const string& api_dir_list,
                       const std::vector<string> op_names)
    : output_path(output_dir), op_names(op_names) {
  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());

  // Decompose the directory components given the output/source directories.
  //

kube::golang::outfile_for_binary() {
  local binary=$1
  local platform=$2
  local output_path="${KUBE_GOPATH}/bin"
  local bin
  bin=$(basename "${binary}")
  if [[ "${platform}" != "${host_platform}" ]]; then
    output_path="${output_path}/${platform//\//_}"
  fi
  if [[ ${GOOS} == "windows" ]]; then
    bin="${bin}.exe"
  fi
  echo "${output_path}/${bin}"
}

# Argument: the name of a Kubernetes package.

Once you have a converted TfLite model ready, you can use the following command
to use TAC to optimize for your model:

```
bazel run -c opt //tensorflow/compiler/mlir/lite/experimental/tac:tac-translate -- <PATH_TO_YOUR_MODEL> -o=<OUTPUT_PATH> -device-specs=<HARDWARE_BACKENDS>
```

The devices_specs is a list of the names of the desired hardware backends,
separated by comma, e.g., "GPU,CPU".